def builderNanodisc(protein, membrane, scaffold, prefixName, runNumber, x=0, y=0, refine=False):
"""
builds a MP-nanodisc systems
scaffold in this case is a double belt of MSP
"""
# Checking time of builder function execution
if protein != None:
print('protein is: ' + protein)
print('scaffold is: ' + scaffold)
print('membrane is: ' + membrane)
empty = False
if protein is None: empty = True
if not empty:
tmp_prot = "tmp_prot" + str(runNumber)
cmd.copy(tmp_prot, protein) # store initial
cmd.translate("[{},{},0]".format(x, y), tmp_prot)
print("State of empty/not-empty: {}".format(empty))
# copies to delete later
tmp_scaffold = "tmp_scaffold" + str(runNumber)
tmp_memb = "tmp_memb" + str(runNumber)
tmp_origin = "origin" + str(runNumber)
cmd.copy(tmp_scaffold, scaffold) # store initial
cmd.copy(tmp_memb, membrane) # store initial
center(tmp_memb)
center(tmp_scaffold)
cmd.pseudoatom(tmp_origin, pos=[0, 0, 0])
cmd.origin(tmp_origin)
#outRadius = findAverDist(tmp_scaffold) #doubles time for each run
outRadius = TMdistCheck(tmp_scaffold, 0.2)
print("Max distance from origin to scaffold in xy plane: {}".format(outRadius))
# remove lipids beyond border encased by MSP
cmd.remove("br. org and {} beyond {} of {}".format(tmp_memb, outRadius, tmp_origin))
# remove lipids clashing with tmp_protein core
if not empty:
avXY = TMdistCheck(tmp_prot, 0.2)
if avXY == -1: return "bad model"
minXY = avXY / 2.0
# remove lipids inside pore
cmd.remove("br. org and {} within {} of {}".format(tmp_memb, minXY, tmp_origin))
print("Mean distance if TM cross-section in xy plane: {}".format(avXY))
if empty:
cmd.remove("br. org and {} within 0.4 of {} and not hydro".format(tmp_memb, tmp_scaffold))
s = "empty_{}_{}".format(membrane, scaffold)
else:
cmd.remove("br. org and {} within 0.3 of pol. and not hydro".format(tmp_memb))
s = "{}_{}_{}".format(protein, membrane, scaffold)
if refine: s += "{}_{}".format(int(x), int(y))
if prefixName:
s = "{}{}".format(prefixName, s)
cmd.create(s, "({},{}, {})".format(protein, tmp_scaffold, tmp_memb))
cmd.save(s + ".pdb", s)
cmd.delete(tmp_memb)
cmd.delete(tmp_scaffold)
cmd.delete(tmp_prot)
cmd.delete(tmp_origin)
return s
def zoom_to_ligand(self):
"""Zoom in too ligand and its interactions."""
cmd.center(self.ligname)
cmd.orient(self.ligname)
cmd.turn('x', 110) # If the ligand is aligned with the longest axis, aromatic rings are hidden
if 'AllBSRes' in cmd.get_names("selections"):
cmd.zoom('%s or AllBSRes' % self.ligname, 3)
else:
if self.object_exists(self.ligname):
cmd.zoom(self.ligname, 3)
cmd.origin(self.ligname)
def builderNanodisc(protein,
membrane,
scaffold,
prefixName,
offset=0,
refine=False):
"""
builds a MP-nanodisc systems
scaffold in this case is a double belt of MSP
"""
# Checking time of builder function execution
print(f'protein is: {protein}')
print(f'scaffold is: {scaffold}')
print(f'membrane is: {membrane}')
empty = False
if protein == None: empty = True
# copies to delete later
cmd.copy("tmp_scaffold", scaffold) # store initial
cmd.copy("tmp_memb", membrane) # store initial
cmd.copy("tmp_prot", protein) # store initial
center("tmp_memb")
center("tmp_scaffold")
cmd.pseudoatom("origin0", pos=[0, 0, 0])
cmd.origin("origin0")
outRadius = findAverDist("tmp_scaffold")
cmd.translate(f"[0,0,{offset}]", f"tmp_scaffold")
print(f"Max distance from origin to scaffold in xy plane: {outRadius}")
# remove lipids beyond border encased by MSP
cmd.remove(f"org and tmp_memb beyond {outRadius} of origin0")
print(f"State of empty/not-empty: {empty}")
# remove lipids clashing with tmp_protein core
if not empty:
avXY = TMdistCheck("tmp_prot", 0.2)
minXY = avXY / 2.0
# remove lipids inside pore
cmd.remove(f"org and tmp_memb within {minXY} of origin0")
print(f"Mean distance if TM cross-section in xy plane: {avXY}")
if empty:
cmd.remove("org and tmp_memb within 0.4 of tmp_scaffold and not hydro")
s = f"{prefixName}empty_{membrane}_{scaffold}"
else:
cmd.remove("org and tmp_memb within 0.3 of pol. and not hydro")
s = f"{prefixName}{protein}_{membrane}_{scaffold}"
if refine: s += str(int(offset))
cmd.create(s, f"({protein},tmp_scaffold, tmp_memb)")
cmd.save(s + ".pdb", s)
cmd.delete("tmp_memb")
cmd.delete("tmp_scaffold")
cmd.delete("tmp_prot")
cmd.delete("origin0")
return s
def testOrigin(self):
from chempy import cpv
cmd.pseudoatom('m1')
cmd.pseudoatom('m2')
cmd.pseudoatom('m3', pos=[1,0,0])
# by selection
cmd.origin('m3')
cmd.rotate('y', 90, 'm1')
# by position
cmd.origin(position=[-1,0,0])
cmd.rotate('y', 90, 'm2')
coords = []
cmd.iterate_state(1, 'm1 m2', 'coords.append([x,y,z])', space=locals())
d = cpv.distance(*coords)
self.assertAlmostEqual(d, 2 * 2**0.5)
def testOrigin(self):
from chempy import cpv
cmd.pseudoatom('m1')
cmd.pseudoatom('m2')
cmd.pseudoatom('m3', pos=[1, 0, 0])
# by selection
cmd.origin('m3')
cmd.rotate('y', 90, 'm1')
# by position
cmd.origin(position=[-1, 0, 0])
cmd.rotate('y', 90, 'm2')
coords = []
cmd.iterate_state(1, 'm1 m2', 'coords.append([x,y,z])', space=locals())
d = cpv.distance(*coords)
self.assertAlmostEqual(d, 2 * 2**0.5)
def builderSalipro(protein,
scaffold,
membrane,
prefixName,
n_sym=9,
initRotAngle=45,
refine=False):
"""
builds and refines MP-salipro systems
"""
# Checking time of builder function execution
print(f'protein is: {protein}')
print(f'scaffold is: {scaffold}')
print(f'membrane is: {membrane}')
print(f'copies of scaffold: {n_sym}')
print(f'rotation angle of scaffold is: {initRotAngle}')
empty = False
if protein == None: empty = True
cmd.reset()
# copies to delete later
cmd.copy("tmp_scaffold", scaffold) # store initial
cmd.copy("tmp_memb", membrane) # store initial
cmd.copy("tmp_prot", protein) # store initial
center("tmp_memb")
center("tmp_scaffold")
cmd.pseudoatom("origin0", pos=[0, 0, 0])
cmd.origin("origin0")
t_sap = 10 # findMaxDist("tmp_scaffold")/2.0 # approximate half thickness of saposin monomer
print(f"State of empty/not-empty: {empty}")
if not empty:
avXY = TMdistCheck("tmp_prot", 0.2)
radXY = avXY / 2.0
# remove lipids inside pore
cmd.remove(f"tmp_memb within {radXY} of origin0")
r_lipHead = 4.7 # Area(POPC) = 65 A^2 => radius = sqrt(A/pi); reasonable estimate
numLipLayers = 2.0 # number of lipid layers between TM of core and Saposin tmp_scaffold
inRadius = avXY + numLipLayers * r_lipHead + t_sap # equatorial position of tmp_scaffold center of mass
else:
inRadius = 27.0 # equatorial position of tmp_scaffold center of mass
outRadius = inRadius + t_sap # cut-lipids beyond this distance
print(f"Inner radius: {inRadius}")
print(f"Outer radius: {outRadius}")
n_sym = int(n_sym)
rotAng = 360. / float(n_sym)
# chain ID
id = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
s0 = range(0, n_sym, 1)
# Build symmates with desired rotations
cmd.rotate("x", "90", "tmp_scaffold")
for i in s0:
angle = +i * rotAng
cmd.copy(f"seg{i}", "tmp_scaffold")
cmd.origin("origin0")
cmd.rotate("y", str(initRotAngle), f"seg{i}")
cmd.origin("origin0")
cmd.translate(f"[0,{inRadius},0]", f"seg{i}")
chn = id[i + len(s0)]
cmd.alter(f"seg{i}", f"chain = '{chn}'")
cmd.origin("origin0")
cmd.rotate("z", str(angle), f"seg{i}")
# remove lipids beyond border encase by saposins
cmd.remove(f"br. org and tmp_memb beyond {outRadius} of origin0")
# remove lipids clashing with tmp_protein core and saposins
if not empty:
cmd.remove("br. org and tmp_memb within 0.3 of pol. and not hydro")
else:
cmd.remove("br. org and tmp_memb within 0.3 of seg* and not hydro")
# Combine into a single PyMol object
if empty == True:
s = f"{prefixName}empty_{membrane}_{scaffold}_{(int)(initRotAngle)}"
else:
s = f"{prefixName}{protein}_{membrane}_{scaffold}_{(int)(initRotAngle)}"
if refine:
s = f"{prefixName}{protein}_{membrane}_{scaffold}_{(int)(initRotAngle)}_{(int)(n_sym)}"
cmd.create(s, f"{protein}, tmp_memb, seg*")
cmd.save(s + ".pdb", s)
cmd.delete("tmp_memb")
cmd.delete("tmp_scaffold")
cmd.delete("tmp_prot")
cmd.delete("seg*")
cmd.delete("origin0")
return s
def reps(self,cleanup=0):
rep_list = [ "lines","sticks","spheres","surface","mesh","dots","ribbon","cartoon" ]
try:
if not cleanup:
cmd.disable()
cmd.set("suspend_updates",1,quiet=1)
cmd.load("$PYMOL_DATA/demo/pept.pdb","rep1")
cmd.alter("rep1///1-5+8-13/","ss='S'")
cmd.cartoon("auto")
cmd.hide("everything","rep1")
for a in range(2,9):
cmd.create("rep%d"%a,"rep1")
for x, y in enumerate(rep_list, 1):
cmd.show(x, "rep%d" % y)
cmd.reset()
cmd.zoom("rep1",24)
util.cbay("rep2")
util.cbac("rep3")
util.cbas("rep4")
util.cbab("rep5")
util.cbaw("rep6")
util.cbay("rep8")
cmd.set("suspend_updates",0,quiet=1)
scale=0.5
for b in range(1,20):
cmd.set("suspend_updates",0,quiet=1)
cmd.refresh()
cmd.set("suspend_updates",1,quiet=1)
xt=-3.2
yt=1.6
for a in range(1,5):
cmd.translate([xt*scale,yt*scale,0],object="rep%d"%a,camera=0)
xt=xt+2
yt=-yt
xt=-3.2
for a in range(5,9):
cmd.translate([xt*scale,yt*scale,0],object="rep%d"%a,camera=0)
xt=xt+2
for a in range(1,9):
cmd.origin("rep%d"%a,object="rep%d"%a)
cmd.mset("1")
st = ' '.join(map(lambda x,y:"rotate angle=-3,object=rep%d,axis=%s;"%(x,y),list(range(1,9)),
['x','y','x','y','x','y','x','y']))
cmd.mdo(1,st)
cmd.set("suspend_updates",0,quiet=1)
cmd.mplay()
cgo = []
axes = [[4.5,0.0,0.0],[0.0,3.0,0.0],[0.0,0.0,3.0]]
c = 1
for a in rep_list:
ext = cmd.get_extent("rep%d"%c)
pos = [(ext[0][0]+ext[1][0])/2,
(ext[0][1]+ext[1][1])/2+14,
(ext[0][2]+ext[1][2])/2]
c = c + 1
pos[0]=pos[0]-(measure_text(plain,a,axes)/2)
wire_text(cgo,plain,pos,a,axes)
cmd.set("cgo_line_width",1.5)
cmd.set("auto_zoom",0)
cmd.load_cgo(cgo,'reps')
cmd.set("auto_zoom",1)
else:
cmd.delete("rep*")
cmd.mset()
cmd.mstop()
except:
traceback.print_exc()
def builderBicelle(protein, membrane, detergent, prefixName, runNumber, refine=False, ang=None, densAng=None):
"""
builds MP - bicelle complex using a membrane and a single detergent molecule
"""
# Checking object names
print('protein is: ' + protein)
print('membrane is: ' + membrane)
print('detergent is: ' + detergent)
empty = False
if protein is None: empty = True
if not empty:
tmp_prot = "tmp_prot" + str(runNumber)
cmd.copy(tmp_prot, protein) # store initial
print("State of empty/not-empty: {}".format(empty))
# copies to delete later
tmp_memb = "tmp_memb" + str(runNumber)
tmp_deter = "tmp_deter" + str(runNumber)
cmd.copy(tmp_memb, membrane) # store initial
cmd.copy(tmp_deter, detergent) # store initial
center(tmp_memb)
center(tmp_deter)
tmp_origin = "origin" + str(runNumber)
cmd.pseudoatom(tmp_origin, pos=[0, 0, 0])
cmd.origin(tmp_origin)
# Determine max distance of TM cross-section (xy plane)
r = TMdistCheck(tmp_prot, 2.0)
if r == -1: return "bad model"
detR = findMaxDist(tmp_deter)
print("Max distance if TM cross-section is in a xy plane: " + str(r))
print("Max distance of detergent : " + str(detR))
## Shrink detergent along z axis to match ry
# stretch = r / detR
# affineStretch("tmp_deter", stretch)
# find new
# detR = detR * stretch
# print(f"Max distance of detergent after shrinking: {detR}")
# Create a ring of detergents using spherical coordinates
# FIXME: find automatically?
if refine:
# stochastic
# theta = random.sample(range(-ang, ang), 10)
# phi = random.sample(range(0, 360), densAng)
# geometrical
theta = np.arange(-ang, ang, 3)
phi = np.arange(0, 361, densAng)
else:
# stochastic
# theta = random.sample(range(-20, 20), 10)
# phi = random.sample(range(0, 361), 100)
# geometrical
theta = range(-14, 14, 3)
phi = range(0, 361, 10) # find angular step from average density?
builderCorona(theta, phi, tmp_deter, r, detR)
#affineStretch("corona", 1.1)
# remove lipids inside pore
cmd.remove("br. {} within {} of {}".format(tmp_memb, r / 2.0, tmp_origin))
cmd.origin(tmp_origin)
# remove lipids beyond border encased by MSP
#print("org and tmp_memb beyond {} of origin0".format(r))
cmd.remove("br. org and {} beyond {} of {}".format(tmp_memb, r, tmp_origin))
# remove lipids clashing with tmp_protein core and MSP scaffold and combine into a single PyMol object
cmd.remove("br. org and {} within 0.3 of pol. and not hydro".format(tmp_memb))
s = "{}_{}_{}".format(protein, membrane, detergent)
if prefixName: s = "{}{}".format(prefixName, s)
cmd.create(s, "({}, corona, {})".format(protein, tmp_memb))
cmd.save(s + ".pdb", s)
cmd.delete("{}, {}, {}, corona".format(tmp_prot, tmp_memb, tmp_deter))
cmd.delete(tmp_origin)
return s
def setOriginAtMolecule(self):
view = np.array(cmd.get_view())
#cmd.origin(position=view[9:12])
cmd.origin(position=self.getMoleculeCoM())
def save_shell_figures(mol_pdb_file,
shell_pdb_files,
graph,
atom_colors,
dpi=3000,
overwrite=False,
out_dir=""):
"""Save all mol/shell/substructure figures."""
cmd.reinitialize()
sleep(0.5)
mol_color_hetero_img = os.path.join(out_dir, "mol_plain.png")
mol_color_types_img = os.path.join(out_dir, "mol_atom_types.png")
pymol_load_with_defaults(mol_pdb_file)
cmd.zoom('all', complete=1, buffer=1)
if overwrite or not os.path.isfile(mol_color_hetero_img):
cmd.util.cbaw()
pymol_color_atoms_by_elem()
cmd.ray(dpi)
cmd.png(mol_color_hetero_img)
partial_opaque_to_opaque(mol_color_hetero_img)
sleep(0.5)
if overwrite or not os.path.isfile(mol_color_types_img):
pymol_color_by_atom_types(atom_colors)
cmd.ray(dpi)
cmd.png(mol_color_types_img)
partial_opaque_to_opaque(mol_color_types_img)
sleep(0.5)
stored.names_ids = []
cmd.iterate("all", "stored.names_ids.append((ID, name))")
ids_names_map = dict(stored.names_ids)
atom_colors = {
ids_names_map[atom_id + 1]: color
for atom_id, color in atom_colors.items()
}
vector_shell_pdb_file = None
vector_shell = None
radii = set()
for pdb_file in shell_pdb_files:
identifier = int(os.path.basename(pdb_file).split('.')[0])
shell_image_file = os.path.join(out_dir,
"{}_shell.png".format(identifier))
graph.node[identifier]["image"] = shell_image_file
if not overwrite and os.path.isfile(shell_image_file):
continue
cmd.reinitialize()
pymol_load_with_defaults(pdb_file)
shell = list(graph.node[identifier]["shell"])[0]
radius = shell.radius
if radius > 0:
radii.add(radius)
draw_shell_sphere(radius, linespacing=radius * .15 / 1.5)
cmd.center('sphere_*')
cmd.origin('sphere_*')
if vector_shell is None and round(
radius / RADIUS_MULTIPLIER) == 1.:
vector_shell_pdb_file = pdb_file
vector_shell = shell
pymol_color_by_atom_types(atom_colors, mode="name")
cmd.turn('y', 90)
cmd.turn('x', 35)
cmd.zoom('all', complete=1)
cmd.ray(dpi)
cmd.png(shell_image_file)
partial_opaque_to_opaque(shell_image_file)
sleep(0.5)
vector_figure = os.path.join(out_dir, "vector_axes.png")
if overwrite or not os.path.isfile(vector_figure):
cmd.reinitialize()
pymol_load_with_defaults(vector_shell_pdb_file)
radius = vector_shell.radius
draw_shell_sphere(radius, linespacing=radius * .15 / 1.5)
center_atom = vector_shell.center_atom
for atom in vector_shell.atoms:
dist = cmd.get_distance(
"{} and id {}".format(vector_shell.identifier, center_atom),
"{} and id {}".format(vector_shell.identifier, atom),
state=1)
if dist <= radius:
coords = cmd.get_coords("{} and id {}".format(
vector_shell.identifier, atom),
state=1)[0]
draw_sphere_marker(radius, coords)
cmd.center('sphere_*')
cmd.origin('sphere_*')
pymol_color_by_atom_types(atom_colors, mode="name")
cmd.turn('y', 90)
cmd.turn('x', 35)
cmd.delete(str(vector_shell.identifier))
cmd.zoom('all', complete=1)
cmd.ray(dpi)
cmd.png(vector_figure)
partial_opaque_to_opaque(vector_figure)
sleep(0.5)
axes_figure = os.path.join(out_dir, "axes.png")
if overwrite or not os.path.isfile(axes_figure):
cmd.reinitialize()
pymol_load_with_defaults()
draw_shell_sphere(min(radii), linespacing=min(radii) * .15 / 1.5)
sleep(.1)
draw_xy_axes(scale=min(radii))
sleep(.1)
cmd.turn('y', 90)
cmd.turn('x', 35)
cmd.zoom('all', complete=1)
cmd.ray(dpi)
cmd.png(axes_figure)
partial_opaque_to_opaque(axes_figure)
sleep(0.5)
def main():
print 'The default filename is points.'
fileName = raw_input('Input file name:')
inputFile = open(fileName,'r')
inputFileList = inputFile.read().splitlines()
pointMap = {}
for i in inputFileList:
tempList = i.split()
pointMap[int(tempList[3])] = Point(float(tempList[0]),float(tempList[1]),float(tempList[2]),int(tempList[3]))
Radius = float(inputFileList[0].split()[2])
r = distance(pointMap[1],pointMap[2])
print 'Eg: R.pdb or R.pse'
outPutFile = raw_input('Input output file name:')
# cmd.pseudoatom('center')
# cmd.set('surface_mode', 1)
# cmd.translate([0,0,0], 'center', camera=1)
# cmd.ramp_new('test', 'center', [640, 646, 647], ['black', 'forest', 'green'])
# cmd.set('surface_color', 'test', 't*')
#Plot the first 4 trimer-center's coordinates.
cmd.load('t1.pdb')
#first trimerIndex
cmd.select('/t1/PSDO')
# cmd.color('blue','t1')
cmd.show('line', 't1')
cmd.rotate ('z', -30, 't1', camera=1)
cmd.translate([0,0,Radius],'t1',camera=1)
#second trimerIndex
cmd.create('t2', 't1')
# cmd.color('red', 't2')
cmd.select('/t2/PSDO')
# cmd.color('yellow', 't2')
cmd.show('line', 't2')
cmd.translate([r, 0, 0], 't2', camera=1)
cmd.orient('t2')
cmd.rotate('z', 60, 't2', camera=1)
cmd.rotate('z', -30 )
#this angle changes to bring involved pseudo atoms to horizontal positions
cmd.rotate('y', 4.726, 't2', camera=1)
cmd.rotate('x', 0.004, 't2', camera=1)
# because we are rotating only one trimer, the 2 central pseudo atoms will not align. correction commands are:
cmd.translate([0, -0.0440605685747639, -2.14176156973178], 't2', camera=1)
# cmd.alter('/t2//A', chain='D')
# cmd.alter('/t2//B', chain='E')
# cmd.alter('/t2//C', chain='F')
#third trimerIndex
cmd.create('t3','t2')
cmd.select('/t3/PSDO')
cmd.show('line','t3')
cmd.origin('t1')
cmd.rotate(pointMap[1].getCoordinate(),120,'t3',camera=1)
#forth trimerIndex
cmd.create('t4','t2')
cmd.select('/t4/PSDO')
cmd.show('line','t4')
cmd.origin('t1')
cmd.rotate(pointMap[1].getCoordinate(),240,'t4',camera=1)
#According to the first 4 trimer-center coordinates, to plot the following trimers.
keyList = pointMap.keys()
keyList.sort()
# testCount = 1
for i in keyList:
if (i>4):
# testCount += 1
tempTName = 't'+str(i)
if (i%2)==1:
tempTFatherName = 't'+str((i-1)/2)
tempDegree = 120
else:
tempTFatherName = 't'+str((i-2)/2)
tempDegree = 240
tempTGrandFatherIndex = ((i-1)//2-1)//2
if tempTGrandFatherIndex == 0:
tempTGrandFatherIndex = 1
tempTGrandFatherName = 't'+str(tempTGrandFatherIndex)
cmd.create(tempTName,tempTGrandFatherName)
cmd.select('/'+tempTName+'/PSDO')
cmd.show('line',tempTName)
cmd.origin(tempTFatherName)
cmd.rotate(pointMap[(i-1)//2].getCoordinate(),tempDegree,tempTName,camera=1)
cmd.save(outPutFile)
def main(d1, d2):
## Make an output folder
outdir = 'output_dd/' + input_protein + '+' + d1 + '+' + d2 + '/'
#print (outdir)
if os.path.isdir(outdir) == False:
os.system('mkdir ' + outdir)
domains = d1 + '+' + d2
for pdb in dd[domains]:
download_pdb_cif(pdb)
for coordinates in dd[domains][pdb]:
#print (pdb, domains, dd[domains][pdb][coordinates])
chainA = coordinates.split('+')[0].split(':')[0]
chainA_res = coordinates.split('+')[0].split(':')[1]
chainB = coordinates.split('+')[1].split(':')[0]
chainB_res = coordinates.split('+')[1].split(':')[1]
cmd.load('pdbs/' + pdb.upper() + '.pdb')
cmd.hide('everything')
cmd.show('cartoon', 'chain ' + chainA + '+' + chainB)
cmd.set('cartoon_fancy_helices', 1)
print(pdb, chainA, chainA_res, chainB, chainB_res)
try:
x = cmd.centerofmass('chain ' + chainA)
print('Success chainA')
cmd.pseudoatom('chainA_label', pos=x)
global nameA
nameA = id_to_name[d1] + '(' + d1 + ')'
cmd.label('chainA_label', 'nameA')
except:
print('Failed chainA')
try:
x = cmd.centerofmass('chain ' + chainB)
print('Success chainB')
cmd.pseudoatom('chainB_label', pos=x)
global nameB
nameB = id_to_name[d2] + '(' + d2 + ')'
cmd.label('chainB_label', 'nameB')
x = cmd.centerofmass('chain ' + chainA + '+' + chainB)
cmd.origin(position=x)
cmd.center('origin')
except:
print('Failed chainB')
cmd.set('label_size', 7.5)
cmd.set('cartoon_fancy_helices', 1)
cmd.color('red', 'chain ' + chainA)
cmd.color('orange', 'chain ' + chainB)
for row in dd[domains][pdb][coordinates]:
res1 = row[2]
res2 = row[3]
#cmd.distance('chain '+chainA+' and i. '+res1+' and n. CB', 'chain '+chainB+' and i. '+res2+' and n. CB')
cutoff = 6.5
m = cmd.distance(
'dist',
'chain ' + chainA + ' and i. ' + res1 + ' and n. CB',
'chain ' + chainB + ' and i. ' + res2 + ' and n. CB',
cutoff, 0)
#m = cmd.get_distance(atom1='chain '+chainA+' and i. '+res1+' and n. CB',atom2='chain '+chainB+' and i. '+res2+' and n. CB',state=0)
#print (pdb, m, chainA, res1, chainB, res2)
cmd.select('res1', 'chain ' + chainA + ' and resi ' + res1)
cmd.select('res2', 'chain ' + chainB + ' and resi ' + res2)
if float(m) != 0.0:
cmd.show('sticks', 'res1')
cmd.show('sticks', 'res2')
cmd.color('cyan', 'res1')
cmd.color('yellow', 'res2')
cmd.save(outdir + pdb + '_' + input_protein + '_' + d1 + '_' +
d2 + '_' + coordinates.replace(':', '_').replace(
'+', '_').replace('-', '_') + '.pse')
cmd.save(outdir + pdb + '_' + input_protein + '_' + d1 + '_' +
d2 + '_' + coordinates.replace(':', '_').replace(
'+', '_').replace('-', '_') + '.pdb')
cmd.delete('all')
#break
'''
#cmd.cd(path)
#else:
#print "No Path specified"
except ValueError:
print "No Path specified"
for file in glob("*.pdb"):
print "file: ", file
listname = file.split(".")
name = listname[0]
cmd.load(file, name)
cmd.system("mv " + file + " ../pdb/")
cmd.hide("all")
cmd.show("sticks")
cmd.reset()
cmd.origin(position=[0.0, 0.0, 0.0])
cmd.save(name + "stix.wrl")
cmd.hide("all")
cmd.show("ribbon")
cmd.reset()
cmd.origin(position=[0.0, 0.0, 0.0])
cmd.save(name + "rib.wrl")
cmd.hide("all")
preset.pretty(name)
cmd.reset()
cmd.origin(position=[0.0, 0.0, 0.0])
cmd.save(name + "cart.wrl")
cmd.hide("all")
cmd.show("surface")
cmd.reset()
cmd.origin(position=[0.0, 0.0, 0.0])
#cmd.cd(path)
#else:
#print "No Path specified"
except ValueError:
print "No Path specified"
for file in glob("*.pdb"):
print "file: ", file
listname = file.split(".")
name = listname[0];
cmd.load(file, name)
cmd.system("mv " + file + " ../pdb/")
cmd.hide("all")
cmd.show("sticks")
cmd.reset()
cmd.origin(position=[0.0,0.0,0.0])
cmd.save(name + "stix.wrl")
cmd.hide("all")
cmd.show("ribbon")
cmd.reset()
cmd.origin(position=[0.0,0.0,0.0])
cmd.save(name + "rib.wrl")
cmd.hide("all")
preset.pretty(name)
cmd.reset()
cmd.origin(position=[0.0,0.0,0.0])
cmd.save(name + "cart.wrl")
cmd.hide("all")
cmd.show("surface")
cmd.reset()
cmd.origin(position=[0.0,0.0,0.0])
from pymol import cmd
from m2_7 import calc_gc
filename = "data/1buw.pdb"
cmd.load(filename)
cmd.hide("everything")
c = cmd.centerofmass("chain A")
cmd.origin(position=c)
cmd.center('origin')
print(cmd.get_position())
cmd.select(
"inside",
"chain A within {:.2f} of origin".format(calc_gc(filename, "chain A")))
cmd.select("outside", "not inside")
cmd.color("red", "inside")
cmd.color("blue", "outside")
cmd.show("sphere", "inside")
cmd.show("sphere", "outside")
def runSurfStamp_(self):
import tempfile
tmpdir = tempfile.TemporaryDirectory()
tmp_outfile = tmpdir.name + "/tmpout.obj"
if len(re.sub("[\s]*", "", self.text_outprefix.text())) > 0:
tmp_outfile = self.text_outprefix.text()
my_view = cmd.get_view()
modelname = self.combo_model.currentText()
output_modelname = re.sub("[^A-Za-z0-9\\.\\-]", "_",
modelname) + "_obj"
output_modelname = cmd.get_unused_name(output_modelname)
surf_args = ["java", "-jar", surfstamp_jar]
surf_args.extend(["-out", tmp_outfile])
tmpmodel_created = ""
if self.check_cartoon.isChecked() or (
not self.check_builtin.isChecked()):
#Use .obj generated by PyMOL. If this step is skipped, built-in generator is used.
tmpmodel_created = cmd.get_unused_name("tmpmodel_")
cmd.load_model(cmd.get_model(modelname), tmpmodel_created)
cmd.set_view((0.9999905824661255, -0.00367919635027647,
-0.002306032460182905, 0.003680833615362644,
0.9999929666519165, 0.0007080769282765687,
0.0023034177720546722, -0.0007165365968830884,
0.999997079372406, 0.0, 0.0, -50.0, 0.0, 0.0, 0.0,
40.0, 100.0, -20.0))
activeobjects = cmd.get_names('public_objects', enabled_only=1)
for aa in list(activeobjects):
cmd.disable(aa)
cmd.enable(tmpmodel_created)
modelname = tmpmodel_created
cmd.hide("everything", modelname)
if self.check_cartoon.isChecked():
cmd.show("cartoon", modelname)
surf_args.extend(["-use_ca", "-force", "-sep_block"])
else:
cmd.show("surface", modelname)
surf_args.extend(["-force"])
cmd.reset()
cmd.origin(position=[0.0, 0.0, 0.0])
cmd.center(origin=0)
unusedname = cmd.get_unused_name("pseudo_")
unused_selectionname = cmd.get_unused_name("pseudo_sel_")
cmd.pseudoatom(unusedname, pos=[0, 0, 0])
cmd.select(unused_selectionname, "/pseudo_//P/PSD`1/PS1")
cmd.center(selection=unused_selectionname)
cmd.save(tmpdir.name + "/tmpin.obj", modelname)
cmd.delete(unusedname)
cmd.delete(unused_selectionname)
for aa in list(activeobjects):
cmd.enable(aa)
surf_args.extend(["-obj", tmpdir.name + "/tmpin.obj"])
cmd.hide("everything", modelname)
if self.check_mmcif.isChecked():
tmp_infile = tmpdir.name + "/tmpin.cif"
surf_args.extend(["-mmcif_use_label", "-mmcif", tmp_infile])
cmd.save(tmp_infile, modelname)
else:
tmp_infile = tmpdir.name + "/tmpin.pdb"
cmd.save(tmp_infile, modelname)
surf_args.extend(["-pdb", tmp_infile])
if len(tmpmodel_created) > 0:
cmd.delete(tmpmodel_created)
surf_args.extend(["-surface_resolution",
str(self.spin_reso.value())])
surf_args.extend(["-image_size",
str(self.spin_imagesize.value())])
if not self.check_outline.isChecked():
surf_args.extend(["-nooutline"])
if self.check_nowater.isChecked():
surf_args.extend(["-nowater"])
if self.check_oneletter.isChecked():
surf_args.extend(["-residue_oneletter"])
if self.check_nochainname.isChecked():
surf_args.extend(["-nochainname"])
if self.check_tile.isChecked():
if self.check_cartoon.isChecked():
surf_args.extend(
["-tile", "-font_size",
str(self.spin_fontsize.value())])
else:
surf_args.extend([
"-tile", "-no_sep", "-font_size",
str(self.spin_fontsize.value())
])
if self.check_colorall.isChecked():
surf_args.extend(["-color_missing", "-color_chainbreak"])
if self.check_ignore_occupancy.isChecked():
surf_args.extend(["-ignore_occupancy"])
surf_args.extend(["-quiet", "1"])
import subprocess
process = subprocess.run(surf_args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
#process = subprocess.run(surf_args, stdout=None, stderr=subprocess.PIPE);
print(process.stdout.decode("utf-8"))
#os.system(" ".join(surf_args)+" >&2 ");
self.label_message.setText("Finished.")
print("Finished.")
self.text_outprefix.setText("")
self.button_ok.setEnabled(True)
self.update()
if not re.search("\.obj$", tmp_outfile):
tmp_outfile = tmp_outfile + ".obj"
cmd.load_callback(pymol_obj_loader.myOBJCallback(tmp_outfile),
output_modelname)
cmd.set_view(my_view)
def builderBicelle(protein,
membrane,
detergent,
prefixName,
refine=False,
ang=None,
densAng=None):
"""
builds MP - bicelle complex using a membrane and a single detergent molecule
"""
# Checking object names
print(f'protein is: {protein}')
print(f'membrane is: {membrane}')
print(f'detergent is: {detergent}')
cmd.copy("tmp_prot", protein) # store initial
cmd.copy("tmp_memb", membrane) # store initial
cmd.copy("tmp_deter", detergent) # store initial
center("tmp_memb")
center("tmp_deter")
cmd.pseudoatom("origin0", pos=[0, 0, 0])
center("tmp_prot")
# Determine max distance of TM cross-section (xy plane)
r = TMdistCheck("tmp_prot", 2.0)
detR = findMaxDist("tmp_deter")
print(f"Max distance if TM cross-section is in a xy plane: {r}")
print(f"Max distance of detergent : {detR}")
# Shrink detergent along z axis to match ry
stretch = r / detR
affineStretch("tmp_deter", stretch)
# find new
detR = detR * stretch
print(f"Max distance of detergent after shrinking: {detR}")
# Create a ring of detergents using spherical coordinates
# FIXME: find automatically?
if refine:
# stochastic
# theta = random.sample(range(-ang, ang), 10)
# phi = random.sample(range(0, 360), densAng)
# geometrical
theta = np.arange(-ang, ang + 1, 5)
phi = np.arange(0, 360, densAng)
else:
# stochastic
# theta = random.sample(range(-20, 20), 10)
# phi = random.sample(range(0, 361), 100)
# geometrical
theta = range(-20, 21, 5)
phi = range(0, 361, 5) # find angular step from average density?
builderCorona(theta, phi, "tmp_deter", r, detR)
affineStretch("corona", 1.1)
# remove lipids inside pore
cmd.remove(f"tmp_memb within {r/2.0} of origin0")
cmd.origin("origin0")
# remove lipids beyond border encased by MSP
print(f"org and tmp_memb beyond {r} of origin0")
cmd.remove(f"org and tmp_memb beyond {r} of origin0")
# remove lipids clashing with tmp_protein core and MSP scaffold and combine into a single PyMol object
cmd.remove("org and tmp_memb within 0.3 of pol. and not hydro")
s = f"{prefixName}{protein}_{membrane}_{detergent}"
cmd.create(s, f"({protein}, corona, tmp_memb)")
cmd.save(s + ".pdb", s)
cmd.delete("tmp_prot, tmp_memb, tmp_deter, corona")
cmd.delete("origin0")
return s
def builderSalipro(protein, scaffold, membrane, prefixName, runNumber, n_sym=9, initRotAngle=45, refine=False):
"""
builds and refines MP-salipro systems
"""
# Checking time of builder function execution
if protein != None:
print('protein is: ' + protein)
print('scaffold is: ' + scaffold)
print('membrane is: ' + membrane)
print('copies of scaffold: ' + str(n_sym))
print('rotation angle of scaffold is: ' + str(initRotAngle))
empty = False
if protein is None: empty = True
print("State of empty/not-empty: {}".format(empty))
cmd.reset()
tmp_prot = "tmp_prot" + str(runNumber)
tmp_scaffold = "tmp_scaffold" + str(runNumber)
tmp_memb = "tmp_memb" + str(runNumber)
tmp_origin = "origin" + str(runNumber)
# copies to delete later
cmd.copy(tmp_scaffold, scaffold) # store initial
cmd.copy(tmp_memb, membrane) # store initial
if not empty:
cmd.copy(tmp_prot, protein) # store initial
center(tmp_memb)
center(tmp_scaffold)
cmd.pseudoatom(tmp_origin, pos=[0, 0, 0])
cmd.origin(tmp_origin)
t_sap = 10 # findMaxDist("tmp_scaffold")/2.0 # approximate half thickness of saposin monomer
if not empty:
avXY = TMdistCheck(tmp_prot, 0.2)
if avXY == -1: return "bad model"
radXY = avXY / 2.0
# remove lipids inside pore
cmd.remove("br. {} within {} of {}".format(tmp_memb, radXY, tmp_origin))
r_lipHead = 4.7 # Area(POPC) = 65 A^2 => radius = sqrt(A/pi); reasonable estimate
numLipLayers = 2.0 # number of lipid layers between TM of core and Saposin tmp_scaffold
inRadius = avXY + numLipLayers * r_lipHead + t_sap # equatorial position of tmp_scaffold center of mass
else:
inRadius = 27.0 # equatorial position of tmp_scaffold center of mass
outRadius = inRadius + t_sap # cut-lipids beyond this distance
print("Inner radius: {}".format(inRadius))
print("Outer radius: {}".format(outRadius))
n_sym = int(n_sym)
rotAng = 360. / float(n_sym)
# chain ID
id = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
s0 = range(0, n_sym, 1)
# Build symmates with desired rotations
cmd.rotate("x", "90", tmp_scaffold)
for i in s0:
angle = + i * rotAng
cmd.copy("seg{}".format(i), tmp_scaffold)
cmd.origin(tmp_origin)
cmd.rotate("y", str(initRotAngle), "seg{}".format(i))
cmd.origin(tmp_origin)
cmd.translate("[0,{},0]".format(inRadius), "seg{}".format(i))
chn = id[i + len(s0)]
cmd.alter("seg{}".format(i), "chain = '{}'".format(chn))
cmd.origin(tmp_origin)
cmd.rotate("z", str(angle), "seg{}".format(i))
# remove lipids beyond border encase by saposins
cmd.remove("br. org and {} beyond {} of {}".format(tmp_memb, outRadius, tmp_origin))
# remove lipids clashing with tmp_protein core and saposins
if not empty:
cmd.remove("br. org and {} within 0.35 of pol. and not hydro".format(tmp_memb))
else:
cmd.remove("br. org and {} within 0.3 of seg* and not hydro".format(tmp_memb))
# Combine into a single PyMol object
if empty:
s = "empty_{}_{}_{}".format(membrane, scaffold, int(initRotAngle))
else:
s = "{}_{}_{}_{}".format(protein, membrane, scaffold, int(initRotAngle))
if refine:
s = "{}_{}_{}_{}_{}".format(protein, membrane, scaffold, int(initRotAngle), int(n_sym))
if prefixName:
s = "{}{}".format(prefixName, s)
# cmd.create(s, protein, tmp_memb, "seg*")
cmd.create(s, "({},{}, seg*)".format(protein, tmp_memb))
cmd.save(s + ".pdb", s)
cmd.delete(tmp_memb)
cmd.delete(tmp_scaffold)
cmd.delete(tmp_prot)
cmd.delete("seg*")
cmd.delete(tmp_origin)
return s
def reps(self, cleanup=0):
rep_list = [
"lines", "sticks", "spheres", "surface", "mesh", "dots", "ribbon",
"cartoon"
]
try:
if not cleanup:
cmd.disable()
cmd.set("suspend_updates", 1, quiet=1)
cmd.load("$PYMOL_DATA/demo/pept.pdb", "rep1")
cmd.alter("rep1///1-5+8-13/", "ss='S'")
cmd.cartoon("auto")
cmd.hide("everything", "rep1")
for a in range(2, 9):
cmd.create("rep%d" % a, "rep1")
for x, y in enumerate(rep_list, 1):
cmd.show(x, "rep%d" % y)
cmd.reset()
cmd.zoom("rep1", 24)
util.cbay("rep2")
util.cbac("rep3")
util.cbas("rep4")
util.cbab("rep5")
util.cbaw("rep6")
util.cbay("rep8")
cmd.set("suspend_updates", 0, quiet=1)
scale = 0.5
for b in range(1, 20):
cmd.set("suspend_updates", 0, quiet=1)
cmd.refresh()
cmd.set("suspend_updates", 1, quiet=1)
xt = -3.2
yt = 1.6
for a in range(1, 5):
cmd.translate([xt * scale, yt * scale, 0],
object="rep%d" % a,
camera=0)
xt = xt + 2
yt = -yt
xt = -3.2
for a in range(5, 9):
cmd.translate([xt * scale, yt * scale, 0],
object="rep%d" % a,
camera=0)
xt = xt + 2
for a in range(1, 9):
cmd.origin("rep%d" % a, object="rep%d" % a)
cmd.mset("1")
st = ' '.join(
map(
lambda x, y: "rotate angle=-3,object=rep%d,axis=%s;" %
(x, y), list(range(1, 9)),
['x', 'y', 'x', 'y', 'x', 'y', 'x', 'y']))
cmd.mdo(1, st)
cmd.set("suspend_updates", 0, quiet=1)
cmd.mplay()
cgo = []
axes = [[4.5, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]]
c = 1
for a in rep_list:
ext = cmd.get_extent("rep%d" % c)
pos = [(ext[0][0] + ext[1][0]) / 2,
(ext[0][1] + ext[1][1]) / 2 + 14,
(ext[0][2] + ext[1][2]) / 2]
c = c + 1
pos[0] = pos[0] - (measure_text(plain, a, axes) / 2)
wire_text(cgo, plain, pos, a, axes)
cmd.set("cgo_line_width", 1.5)
cmd.set("auto_zoom", 0)
cmd.load_cgo(cgo, 'reps')
cmd.set("auto_zoom", 1)
else:
cmd.delete("rep*")
cmd.mset()
cmd.mstop()
except:
traceback.print_exc()
def setOriginAtCamera(self):
view = np.array(cmd.get_view())
# concise version
cmd.origin(position=view[12:15] -
view[9:12].dot(view[0:9].reshape((3, 3)).T))
