def testStereo(self):
cmd.fragment('ala')
cmd.remove('hydro')
# default: S configuration
labels = []
cmd.iterate('name CA', 'labels.append(stereo)', space=locals())
self.assertEqual(labels, ['S'])
# load R configuration (moves CB)
ala_conf_R = {
'N': (-0.67690, -1.23030, -0.49050),
'CA': (-0.00090, 0.06370, -0.49050),
'C': (1.49910, -0.11030, -0.49050),
'O': (2.03010, -1.22730, -0.50150),
# 'CB' : (-0.50890, 0.85570, 0.72650), # S configuration
'CB': (-0.33784, 0.82664, -1.78310), # R configuration
}
cmd.alter_state(1,
'ala',
'(x,y,z) = ala_conf_R.get(name)',
space=locals())
labels = []
cmd.iterate('name CA', 'labels.append(stereo)', space=locals())
self.assertEqual(labels, ['R'])
def _testLabelByAtomType(self):
cmd.load(self.datafile('1oky.pdb.gz'))
cmd.remove("alt 'B'")
cmd.label('resn STU', 'text_type')
c3labels = []
cmd.iterate("resn STU", "c3labels.append(label == 'C.3')", space=locals())
self.assertEquals(sum(c3labels), 8)
def load():
cmd.set("valence")
r = 0
list = glob("pdb/*/*")
# list = ["pdb/06/pdb406d"]
# while list[0]!="pdb/f8/pdb1f8u":
# list.pop(0)
for file in list:
cmd.delete('pdb')
cmd.load(file,'pdb')
cmd.remove("not alt ''+A")
cmd.fix_chemistry("all","all")
cmd.h_add()
sys.__stderr__.write(file)
sys.__stderr__.flush()
ch = Champ()
model = cmd.get_model('pdb')
idx = ch.insert_model(model)
ch.pattern_orient_bonds(idx)
print " %5d"%cmd.count_atoms(),"%5d"%len(ch.pattern_get_string(idx)),
ch.pattern_detect_chirality(idx)
pat = ch.pattern_get_string(idx)
print "%5d"%len(pat),pat[0:22]+"..."+pat[-10:]
def findSurfaceResidues(objSel="(all)",
cutoff=2.5,
doShow=False,
verbose=False):
tmpObj = "__tmp"
cmd.create(tmpObj, objSel + " and polymer")
if verbose != False:
print("WARNING: I'm setting dot_solvent. You may not care for this.")
cmd.set("dot_solvent")
cmd.get_area(selection=tmpObj, load_b=1)
cmd.remove(tmpObj + " and b < " + str(cutoff))
stored.tmp_dict = {}
cmd.iterate(tmpObj, "stored.tmp_dict[(chain,resv)]=1")
exposed = stored.tmp_dict.keys()
exposed.sort()
randstr = str(random.randint(0, 10000))
selName = "exposed_atm_" + randstr
if verbose != False:
print("Exposed residues are selected in: " + selName)
cmd.select(selName, objSel + " in " + tmpObj)
selNameRes = "exposed_res_" + randstr
cmd.select(selNameRes, "byres " + selName)
if doShow != False:
cmd.show_as("spheres", objSel + " and poly")
cmd.color("white", objSel)
cmd.color("red", selName)
cmd.delete(tmpObj)
return exposed
def fetch_scop(code, name='', **kwargs):
if name == '':
name = code
kwargs['async'] = 0
r = fetch(code[1:5], name, **kwargs)
if cmd.is_error(r):
return r
try:
import Bio.SCOP
import MySQLdb
conn = MySQLdb.connect(**mysql_kwargs)
scop = Bio.SCOP.Scop(db_handle=conn)
d = scop.getDomainBySid(code)
if len(d.residues.fragments) > 0:
rsele = ''
for frag in d.residues.fragments:
chain, start, stop = frag
rsele += ' (chain ' + chain
if start and stop:
rsele += ' and resi %s-%s' % (start, stop)
rsele += ')'
cmd.remove(name + ' and not (' + rsele + ')')
except:
print(' Warning: SCOP domain resiude range handling failed')
return -1
def cheshift(pdb_path,cs_path):
"""Conects to CheShift to send and receive data"""
pdb_filename = pdb_path.split('/')[-1]
pdb_filenamenoext = re.sub(r'[^A-Za-z0-9-.]', '', pdb_filename.split('.')[0])
cs_filename = cs_path.split('/')[-1]
# Send data to CheShift.com and captures the name of the new web page.
br = mechanize.Browser()
br.set_handle_refresh(False)
br.set_proxies(proxy_values)
try:
br.open('http://www.cheshift.com/visual_test.html')
br.select_form(nr=0)
br.form.add_file(open(pdb_path), "chemical/x-pdb", pdb_filename,
name = 'uploaded')
br.form.add_file(open(cs_path), "text/plain", cs_filename, name='CS_file')
br.form.set_value([ref_value.get()],name='radiogroup')
br.form.set_all_readonly(False)
response = br.submit().geturl()
subfix = response.split('/')[-1].split('.')[0]
except:
Pmw.MessageDialog(title='Error',message_text=('Something went wrong while processing your request\n Please check your files and try again\n\nIf you could not find the problem please send and e-mail to [email protected]'))
# Checks if the colored PDB file was created or if something went wrong
test = 0
while True:
try:# If the colored PDB was created, creates a local temporal PDB file
# and loads that file into PyMOL.
result = br.open('http://www.cheshift.com/jobs/%s/%s_b.pdb?r=%d' % (subfix, pdb_filenamenoext, test)).read()
fd = tempfile.NamedTemporaryFile(bufsize=0,delete=False)
fd.write(result)
fd.close()
pdb_tmp = fd.name
pdblist = []
for line in open(pdb_tmp).readlines():
if 'ATOM' in line:
pdblist.append(line)
first = int(pdblist[0][22:26])
last = int(pdblist[-1][22:26])
cmd.reinitialize()
rename = ('%s_b.pdb' % (pdb_filenamenoext))
cmd.load(pdb_tmp, rename)
#CheShift does not provide results for the first or last residue
cmd.remove('resi %s' % first)
cmd.remove('resi %s' % last)
colorize()
break
except:
test += 1
try:# check for posible errors
result = br.open('http://www.cheshift.com/jobs/%s/error.txt?r=%d' % (subfix, test)).read().split() # behind a proxy you need to add a "dummy" modifier to the requested file (?r=%d'). Otherwise you will just be checking the cached file and not the actual file.
if int(result[0]) == 0:
Pmw.MessageDialog(title = 'Error',message_text=('The residue at position %s is missing from your PDB file\n Please fix the problem and try again' % (result[1])))
elif int(result[0]) == 1:
Pmw.MessageDialog(title = 'Error',message_text = ('The residue %s%s in your PDB file does not match\n with residue %s%s in your chemical shift file.\n\n Please check your files and try again' % (result[1], result[3], result[2], result[3])))
else:
Pmw.MessageDialog(title = 'Error',message_text=('Something went wrong while processing your request\n Please check your files and try again\n\nIf you could not find the problem please write to us'))
break
except:
pass
time.sleep(5)
def process_molecule_mae(file_header, mol, suspend_undo):
global already_processed
global undo_each_molecule
tot = []
tot.extend(file_header)
tot.extend(mol)
molstr = string.join(tot,'')
nameorig, mdl = read_mae_model(molstr)
name = nameorig.strip()
if name in already_processed:
return True
already_processed = set(already_processed | set([name]))
tmpname = "_temp_%s" % name
cmd.delete(tmpname)
try:
cmd.load_model(mdl, tmpname)
natoms = cmd.count_atoms(tmpname)
except:
return False
if undo_each_molecule:
cmd.push_undo( "( %s )" % name, just_coordinates=0)
cmd.set("suspend_undo", 1, updates=0)
cmd.remove(name)
cmd.create(name, tmpname, copy_properties=True)
cmd.set_title(name, -1, "")
cmd.delete(tmpname)
if undo_each_molecule:
cmd.set("suspend_undo", suspend_undo, updates=0)
cmd.push_undo("", just_coordinates=0, finish_undo=1)
return True
def test(self):
cmd.fab('AG')
cmd.remove('hydro')
cmd.h_add('resn ALA')
# with this bug: count = 6
self.assertEqual(11, cmd.count_atoms('byres (last hydro)'))
def load_rep(target, offtarget):
tprot = target[0]
tprot_type = target[1]
tligs = target[2:]
cmd.load(tprot, tprot_type)
for lig in tligs:
cmd.load(lig, '%s_poses' % tprot_type[0])
ligand_cartoon('(%s_poses or %s)' % (tprot_type[0], tprot_type))
cmd.set_name('polar_contacts', '%s_polar_contacts' % tprot_type[0])
util.cbag('(%s_poses or %s)' % (tprot_type[0], tprot_type))
if offtarget:
oprot = offtarget[0]
oprot_type = offtarget[1]
oligs = offtarget[2:]
cmd.load(oprot, 'Off-Target')
for lig in oligs:
cmd.load(lig, 'O_poses')
ligand_cartoon('(O_poses or Off-Target)')
cmd.set_name('polar_contacts', 'O_polar_contacts')
util.cbam('(O_poses or Off-Target)')
# cmd.bg_color('white')
# representation(rep)
cmd.remove("all & hydro & not nbr. (don.|acc.)")
def homogenizechains(sel1,sel2):
cmd.remove("hydro")
cmd.remove("resn HOH")
cmd.remove("(HET and not resn MSE+CSW)")
a = cmd.get_model("%s and name ca"%(sel1))
b = cmd.get_model("%s and name ca"%(sel2))
sa = "".join([name1[x.resn] for x in a.atom])
sb = "".join([name1[x.resn] for x in b.atom])
if sa==sb: return True
ra = [myint(x.resi) for x in a.atom]
rb = [myint(x.resi) for x in b.atom]
# if max(ra) - min(ra) + 1 != len(ra): print "missing residue numbers",max(ra),min(ra),len(ra)
# if max(rb) - min(rb) + 1 != len(rb): print "missing residue numbers",rb
mla,mua,mlb,mub = lcs(sa,sb)
bla,bua,blb,bub = lcs(sa[ :mla],sb[ :mlb])
ala,aua,alb,aub = lcs(sa[mua+1:],sb[mub+1:])
ra = ra[mla:(mua+1)]
rb = rb[mlb:(mub+1)]
if len(ra[bla:(bua+1)]) > 10:
ra = ra[bla:(bua+1)] + ra[mla:(mua+1)] + ra[ala:(aua+1)]
rb = rb[blb:(bub+1)] + rb[mlb:(mub+1)] + rb[alb:(aub+1)]
if len(ra[ala:(aua+1)]) > 10:
ra += ra[ala:(aua+1)]
rb += rb[alb:(aub+1)]
for c,i in getres("%s"%(sel1)):
if not i in ra: cmd.remove("%s and resi %i"%(sel1,i))
for c,i in getres("%s"%(sel2)):
if not i in rb: cmd.remove("%s and resi %i"%(sel2,i))
return False
def alignc4(sele,alignsele=None,tgtaxis=Vec(0,0,1),chains=["A","B","C","D"]): if alignsele is None: alignsele = sele cmd.remove(sele+" and resn HOH") axis = c3axis(sele,alignsele,chains) # print "axis of rotation:",axis alignaxis(sele,tgtaxis,axis,Vec(0,0,0)) return True
def reload_system(self, ln: str, smis: oechem.OEMol, old_pdb: str, is_oe_already: bool = False):
with self.logger("reload_system") as logger:
logger.log("Loading {} with new smiles {}".format(old_pdb, ln))
with tempfile.TemporaryDirectory() as dirpath:
ofs = oechem.oemolostream("{}/newlig.mol2".format(dirpath))
oechem.OEWriteMolecule(ofs, smis)
ofs.close()
cmd.reinitialize()
cmd.load(old_pdb)
cmd.remove("not polymer")
cmd.load("{}/newlig.mol2".format(dirpath), "UNL")
cmd.alter("UNL", "resn='UNL'")
cmd.alter("UNL", "chain='A'")
self.config.pdb_file_name = self.config.tempdir() + "reloaded.pdb"
cmd.save(self.config.pdb_file_name)
cmd.save(self.config.tempdir() + "apo.pdb")
with open(self.config.pdb_file_name, 'r') as f:
self.pdb = app.PDBFile(f)
self.positions, self.topology = self.pdb.getPositions(), self.pdb.getTopology()
if self.config.explicit and self.config.method == 'amber':
self.system, self.topology, self.positions = self.__setup_system_ex_amber(
pdbfile=self.config.pdb_file_name)
elif self.config.explicit:
self.system, self.topology, self.positions = self.__setup_system_ex_mm()
else:
self.system, self.topology, self.positions = self.__setup_system_im( pdbfile=self.config.pdb_file_name)
return self.system
def testUndoAfterRemoveAtomOnDiscrete(self, discr):
cmd.set('suspend_undo', 0)
cmd.load(self.datafile('ligs3d.sdf'), discrete=discr)
natms = cmd.count_atoms()
cmd.remove("index 1")
cmd.undo()
self.assertEqual(natms, cmd.count_atoms())
def findSurfaceAtoms(selection="all", cutoff=2.5, quiet=1):
"""
DESCRIPTION
Finds those atoms on the surface of a protein
that have at least 'cutoff' exposed A**2 surface area.
USAGE
findSurfaceAtoms [ selection, [ cutoff ]]
SEE ALSO
findSurfaceResidues
"""
cutoff, quiet = float(cutoff), int(quiet)
tmpObj = cmd.get_unused_name("_tmp")
cmd.create(tmpObj, "(" + selection + ") and polymer", zoom=0)
cmd.set("dot_solvent", 1, tmpObj)
cmd.get_area(selection=tmpObj, load_b=1)
# threshold on what one considers an "exposed" atom (in A**2):
cmd.remove(tmpObj + " and b < " + str(cutoff))
selName = cmd.get_unused_name("exposed_atm_")
cmd.select(selName, "(" + selection + ") in " + tmpObj)
cmd.delete(tmpObj)
if not quiet:
print("Exposed atoms are selected in: " + selName)
return selName
def additional_cleanup(self):
"""Cleanup of various representations"""
cmd.remove('not alt ""+A') # Remove alternate conformations
cmd.hide('labels', 'Interactions') # Hide labels of lines
cmd.disable('%sCartoon' % self.protname)
cmd.hide('everything', 'hydrogens')
def revert(self):
v = cmd.get_view()
cmd.remove(self.rdes.obj+" and not chain A")
m = cmd.get_model(self.rdes.obj)
n = self.oldcrd
if not n:
cmd.create("tmp12345",self.rnat.sel())
cmd.align("tmp12345",self.rdes.sel())
n = cmd.get_model("tmp12345").atom
cmd.delete("tmp12345")
di,ni = 0,0
while m.atom[di].resi != str(self.rdes.resi): di += 1
dj = di
while m.atom[dj].resi == str(self.rdes.resi): dj += 1
if self.oldcrd: self.oldcrd = None
else: self.oldcrd = m.atom[di:dj]
m.atom = m.atom[:di] + n + m.atom[dj:]
for i in range(di,di+len(n)):
m.atom[i].resi = str(self.rdes.resi)
m.atom[i].chain = str(self.rdes.chain)
cmd.load_model(m,self.rdes.obj,1)
cmd.save("tmp.pdb",self.rdes.obj)
cmd.delete(self.rdes.obj)
cmd.load("tmp.pdb",self.rdes.obj,1)
cmd.show('car',self.rdes.obj)
cmd.show('lines')
redopent(self.rdes.obj)
cmd.set_view(v)
print "revert removing "+"".join(self.aas)+" from aas!"
self.aas = [getaa('A',self.rdes.resi,self.manager.d.obj)]
def slowpacking(pdb):
"Derive mean packing density of pdb as pd.Series."
cmd.delete('all')
cmd.load(pdb)
cmd.remove('solvent')
# Only heavy atoms
cmd.remove('hydro')
# Compute SAS per atom
cmd.set('dot_solvent')
cmd.get_area('all', load_b=1)
N = float(cmd.select('interior', 'b = 0'))
internal_coords = [at.coord for at in cmd.get_model('interior').atom]#[1:50]
all_coords = [at.coord for at in cmd.get_model('all').atom]#[1:50]
# Count
counts = pd.Series(0, index=RADS)
for a, b in product(internal_coords, all_coords):
es = euclid_step(a, b)
if es is not None:
counts.loc[es] += 1
counts = counts.cumsum()
# Mean per center atom
meancounts = counts / N
# Normalize to density
volumina = pd.Series(4 / 3.0 * sp.pi * (RADS ** 3), index=RADS)
density = meancounts / volumina
# Correct for center
density -= 1 / (4/3 * sp.pi * RADS ** 3)
# Results
counts.index = ["{}_correctcount".format(i) for i in counts.index]
density.index = ["{}_density".format(i) for i in density.index]
return pd.concat(([counts, density]))
def load(self):
self.manager.d = self
self.manager.m = None
self.manager.m = None # to also set prevm = None
# cmd.delete(self.manager.prevd.obj)
# cmd.delete(self.manager.prevd.pid)
# print self.manager.d.obj
# print self.manager.prevd.obj
# sys.exit()
cmd.delete("all")
cmd.load(self.getloadname(),self.obj,1)
cmd.remove(self.obj+" and not chain A")
cmd.fetch(self.pid)
cmd.remove("het or hydro")
cmd.color('gray',self.pid+' and elem C')
self.scores['rms'] = cmd.align(self.pid,self.obj+" and chain A")[0]
cmd.hide('ev')
cmd.show('lines')
cmd.show("car")
#cmd.disable(self.pid)
redopent(self.obj)
self.recalc_design_pos()
self.read_data_dir('avg_deg')
self.read_data_dir('ddG')
self.read_data_dir('rot_boltz')
self.read_bup()
self.read_tot_scores()
self.read_res_scores()
cmd.orient(self.obj+" or pnt*")
self.manager.m = self.remembermm
if self.manager.m: self.manager.m.focus()
if self.remembermv: cmd.set_view(self.remembermv)
def morph_movie(morph,
view,
color,
base_name,
frameno_offset=0,
morph_reverse=False):
number_of_states = cmd.count_states(morph)
# after this I will have each state available as its own object, called "{morphname}_000x" (padded to length of 4)
# x starts with 1 --> not clear - that might depend on the numbering in the input file
cmd.split_states(morph)
last_frame = frameno_offset
for statenum in range(0, number_of_states + 1):
if morph_reverse:
statenum = max(1, cmd.count_states(morph) - statenum)
else:
statenum = min(statenum + 1, cmd.count_states(morph))
state_name = morph + "_" + str(statenum).zfill(4)
clump_representation([state_name], color, state_name),
cmd.set_view(view)
cmd.png(base_name + str(last_frame).zfill(3),
width=1920,
height=1080,
ray=True)
clump_cleanup([state_name], state_name)
cmd.remove(state_name)
last_frame += 1
return last_frame
def test_add_missing_atoms():
cmd.reinitialize()
cmd.load(DATA_PATH / '2x19-frag-mse.pdb')
cmd.remove("not backbone")
assert cmd.count_atoms("resi 132") == 4
psico.modelling.add_missing_atoms('resi 132+133', cycles=10)
assert cmd.count_atoms("resi 132") == 8
def fetch_cath(code, name='', **kwargs):
if name == '':
name = code
kwargs['async'] = 0
r = fetch(code[:4], name, **kwargs)
if cmd.is_error(r):
return r
if code[5:7] == '00':
if code[4] != '0':
cmd.remove(name + ' and not chain ' + code[4])
else:
try:
if len(cath_domains) == 0:
cath_parse_domall()
d = cath_domains[code]
rsele = ''
for frag in d:
chain, start, stop = frag
rsele += ' (chain ' + chain
if start and stop:
rsele += ' and resi %s-%s' % (start, stop)
rsele += ')'
cmd.remove(name + ' and not (' + rsele + ')')
except:
print(' Warning: CATH domain resiude range handling failed')
return -1
def fetch_cath(code, name='', **kwargs):
if name == '':
name = code
r = fetch(code[:4], name, async=0, **kwargs)
if cmd.is_error(r):
return r
if code[5:7] == '00':
if code[4] != '0':
cmd.remove(name + ' and not chain ' + code[4])
else:
try:
if len(cath_domains) == 0:
cath_parse_domall()
d = cath_domains[code]
rsele = ''
for frag in d:
chain, start, stop = frag
rsele += ' (chain ' + chain
if start and stop:
rsele += ' and resi %s-%s' % (start, stop)
rsele += ')'
cmd.remove(name + ' and not (' + rsele + ')')
except:
print ' Warning: CATH domain resiude range handling failed'
return -1
def prepareprot_scaffold(preload, presave, receptor, postload, postsave,
algchoice):
canproceed = False
cmd.load(preload + receptor + postload)
all_chains = cmd.get_chains(receptor)
print(
f'Which chains would you like to keep for protein {receptor}. It has following chains: ',
all_chains)
selectedchain = input(
"Type the chain names seperated by space, \nif you want all chains, type 'all': "
)
chainstoremove = set(all_chains) - set(selectedchain.split(' '))
if set(selectedchain.split(' ')).issubset(set(all_chains)):
for chain in chainstoremove:
cmd.remove('chain ' + chain)
print(f'Chain {chain} removed.')
canproceed = True
elif selectedchain == 'all':
print('All chains selected.')
canproceed = True
else:
print(
'Wrong chain selection. Type it like "A B 6" if you have three chains named A, B and 6'
)
if canproceed:
cmd.remove('resn HOH')
#cmd.h_add(selection='acceptors or donors')
cmd.save(presave + receptor + postsave)
subprocess.call(
shlex.split(f'./prepareprot.sh {receptor} {algchoice}'))
def findSurfaceAtoms(selection="all", cutoff=2.5, quiet=1):
"""
DESCRIPTION
Finds those atoms on the surface of a protein
that have at least 'cutoff' exposed A**2 surface area.
USAGE
findSurfaceAtoms [ selection, [ cutoff ]]
SEE ALSO
findSurfaceResidues
"""
cutoff, quiet = float(cutoff), int(quiet)
tmpObj = cmd.get_unused_name("_tmp")
cmd.create(tmpObj, "(" + selection + ") and polymer", zoom=0)
cmd.set("dot_solvent", 1, tmpObj)
cmd.get_area(selection=tmpObj, load_b=1)
# threshold on what one considers an "exposed" atom (in A**2):
cmd.remove(tmpObj + " and b < " + str(cutoff))
selName = cmd.get_unused_name("exposed_atm_")
cmd.select(selName, "(" + selection + ") in " + tmpObj)
cmd.delete(tmpObj)
if not quiet:
print("Exposed atoms are selected in: " + selName)
return selName
def fetch_scop(code, name='', **kwargs):
if name == '':
name = code
kwargs['async'] = 0
r = fetch(code[1:5], name, **kwargs)
if cmd.is_error(r):
return r
try:
import Bio.SCOP
import MySQLdb
conn = MySQLdb.connect(**mysql_kwargs)
scop = Bio.SCOP.Scop(db_handle=conn)
d = scop.getDomainBySid(code)
if len(d.residues.fragments) > 0:
rsele = ''
for frag in d.residues.fragments:
chain, start, stop = frag
rsele += ' (chain ' + chain
if start and stop:
rsele += ' and resi %s-%s' % (start, stop)
rsele += ')'
cmd.remove(name + ' and not (' + rsele + ')')
except:
print(' Warning: SCOP domain resiude range handling failed')
return -1
def pymol_mutate(file_name, chain, res_index):
pymol.finish_launching()
cmd.delete('all')
selection = chain + '/' + res_index + '/'
mutant = 'CYS'
cmd.wizard("mutagenesis")
pdb = file_name[:-4]
cmd.load(file_name)
cmd.remove('not (alt ''+A)')
cmd.select('mut', 'resi ' + res_index + ' and chain ' + chain)
if cmd.count_atoms('mut') == 0:
return False
cmd.refresh_wizard()
cmd.get_wizard().set_mode(mutant)
cmd.get_wizard().do_select(selection)
nStates = cmd.count_states("mutation")
for i in range(1, nStates + 1):
cmd.get_wizard().do_select(selection)
cmd.frame(i)
cmd.get_wizard().apply()
cmd.save("rec_" + str(res_index) + "_" + str(i) + ".pdb")
cmd.set_wizard()
cmd.remove(file_name[:-4])
return True
def fetch_scop(code, name="", **kwargs):
if name == "":
name = code
r = fetch(code[1:5], name, async=0, **kwargs)
if cmd.is_error(r):
return r
try:
import Bio.SCOP
import MySQLdb
conn = MySQLdb.connect(**mysql_kwargs)
scop = Bio.SCOP.Scop(db_handle=conn)
d = scop.getDomainBySid(code)
if len(d.residues.fragments) > 0:
rsele = ""
for frag in d.residues.fragments:
chain, start, stop = frag
rsele += " (chain " + chain
if start and stop:
rsele += " and resi %s-%s" % (start, stop)
rsele += ")"
cmd.remove(name + " and not (" + rsele + ")")
except:
print " Warning: SCOP domain resiude range handling failed"
return -1
def fetch_cath(code, name="", **kwargs):
if name == "":
name = code
r = fetch(code[:4], name, async=0, **kwargs)
if cmd.is_error(r):
return r
if code[5:7] == "00":
if code[4] != "0":
cmd.remove(name + " and not chain " + code[4])
else:
try:
if len(cath_domains) == 0:
cath_parse_domall()
d = cath_domains[code]
rsele = ""
for frag in d:
chain, start, stop = frag
rsele += " (chain " + chain
if start and stop:
rsele += " and resi %s-%s" % (start, stop)
rsele += ")"
cmd.remove(name + " and not (" + rsele + ")")
except:
print " Warning: CATH domain resiude range handling failed"
return -1
def testUndoAfterRemoveAtomOnDiscrete(self, discr):
cmd.set('suspend_undo', 0)
cmd.load(self.datafile('ligs3d.sdf'), discrete=discr)
natms = cmd.count_atoms()
cmd.remove("index 1")
cmd.undo()
self.assertEqual(natms, cmd.count_atoms())
def process_molecule_sdf(mol, suspend_undo):
global already_processed
global undo_each_molecule
nameorig = mol[0]
name = nameorig.strip()
if name in already_processed:
return True
already_processed = set(already_processed | set([name]))
tmpname = "_temp_%s" % name
molstr = string.join(mol,'')
cmd.delete(tmpname)
try:
importing.read_sdfstr(molstr, tmpname,object_props='*')
natoms = cmd.count_atoms(tmpname)
except:
return False
if undo_each_molecule:
cmd.push_undo( "( %s )" % name, just_coordinates=0)
cmd.set("suspend_undo", 1, updates=0)
cmd.remove(name)
print "before cmd.create(): using copy_properties=True"
cmd.create(name, tmpname, copy_properties=True)
cmd.set_title(name, -1, "")
cmd.delete(tmpname)
if undo_each_molecule:
cmd.set("suspend_undo", suspend_undo, updates=0)
cmd.push_undo("", just_coordinates=0, finish_undo=1)
return True
def findSurfaceResidues(objSel="(all)", cutoff=2.5, doShow=False, verbose=True):
"""
findSurfaceResidues
finds those residues on the surface of a protein
that have at least 'cutoff' exposed A**2 surface area.
PARAMS
objSel (string)
the object or selection in which to find
exposed residues
DEFAULT: (all)
cutoff (float)
your cutoff of what is exposed or not.
DEFAULT: 2.5 Ang**2
asSel (boolean)
make a selection out of the residues found
RETURNS
(list: (chain, resv ) )
A Python list of residue numbers corresponding
to those residues w/more exposure than the cutoff.
"""
tmpObj="__tmp"
cmd.create( tmpObj, objSel + " and polymer");
if verbose!=False:
print "WARNING: I'm setting dot_solvent. You may not care for this."
cmd.set("dot_solvent");
cmd.get_area(selection=tmpObj, load_b=1)
# threshold on what one considers an "exposed" atom (in A**2):
cmd.remove( tmpObj + " and b < " + str(cutoff) )
stored.tmp_dict = {}
cmd.iterate(tmpObj, "stored.tmp_dict[(chain,resv)]=1")
exposed = stored.tmp_dict.keys()
exposed.sort()
randstr = str(random.randint(0,10000))
selName = "exposed_atm_" + randstr
if verbose!=False:
print "Exposed residues are selected in: " + selName
cmd.select(selName, objSel + " in " + tmpObj )
selNameRes = "exposed_res_" + randstr
cmd.select(selNameRes, "byres " + selName )
if doShow!=False:
cmd.show_as("spheres", objSel + " and poly")
cmd.color("white", objSel)
cmd.color("red", selName)
cmd.delete(tmpObj)
print exposed
return exposed
def fSumWMCresidue(molecule, SGNameAngle, chain, residue, MCNeighbour,
DieElecMC, MCchargeC, MCchargeO, MCchargeN, MCchargeH,
AmideName, printMC):
# print "residue", MCNeighbour
SumWMCresidue = 0.0
SGnameselect = "/" + SGNameAngle + "//" + "/" + "/SG"
NBnameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour)
cmd.select("MC", NBnameselect)
MCpdbstr = cmd.get_pdbstr("MC")
MCsplit = MCpdbstr.split()
residueName = MCsplit[3]
# print NBnameselect, residueName
AmideProt = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/H01"
Hnameselect = "/" + AmideName + "//" + chain + "/" + str(
MCNeighbour) + "/H01"
if cmd.count_atoms(AmideProt) == 0 and cmd.count_atoms(Hnameselect) == 0:
HbuildSelect = "/" + molecule + "//" + chain + "/" + str(
MCNeighbour) + "/N"
cmd.h_add(HbuildSelect)
cmd.create(AmideName, AmideName + " + " + AmideProt)
cmd.remove(AmideProt)
# Mainchain AmideH
ResDist = cmd.dist(residue + 'distResH', SGnameselect, Hnameselect)
WMC = fWMC(MCchargeH, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC H ", MCNeighbour, " ", MCchargeH, " ", DieElecMC, " ",
ResDist, " ", WMC)
# Mainchain C
Cnameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/C"
ResDist = cmd.dist(residue + 'distResC', SGnameselect, Cnameselect)
WMC = fWMC(MCchargeC, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC C ", MCNeighbour, " ", MCchargeC, " ", DieElecMC, " ",
ResDist, " ", WMC)
# Mainchain O
Onameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/O"
ResDist = cmd.dist(residue + 'distResO', SGnameselect, Onameselect)
WMC = fWMC(MCchargeO, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC O ", MCNeighbour, " ", MCchargeO, " ", DieElecMC, " ",
ResDist, " ", WMC)
# Mainchain N
Nnameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/N"
ResDist = cmd.dist(residue + 'distResN', SGnameselect, Nnameselect)
WMC = fWMC(MCchargeN, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC N ", MCNeighbour, " ", MCchargeN, " ", DieElecMC, " ",
ResDist, " ", WMC)
cmd.delete(residue + 'distResH')
cmd.delete(residue + 'distResC')
cmd.delete(residue + 'distResO')
cmd.delete(residue + 'distResN')
cmd.show("nb_spheres", AmideName)
cmd.delete("MC")
return SumWMCresidue
def read_siftp(filename):
try:
#first line in file contains averaged sift
with open(filename, 'r') as f:
siftline = f.readline()
min_aa, sift = siftline.split(':')
sift = sift.split(' ')
print sift
for interaction in range(9):
selection = []
for index in range(len(sift[interaction::9])):
if index == len(sift[interaction::9]) - 1:
print len(sift[interaction::9])
print 'index',index,
print 'interaction',sift[interaction::9][index]
if sift[interaction::9][index].strip() != '0':
if interaction == 8:
print sift[interaction::9][index]
print int(min_aa) + index
print sift[index:index + 9]
selection.append(str(int(min_aa)+index))
if len(selection) > 0:
cmd.select ( InteractionButton[interaction]+'_'+InteractionName[interaction], 'resi ' + "+".join(selection) )
if interaction == 0:
cmd.show ( 'sticks', InteractionButton[interaction]+'_'+InteractionName[interaction] )
cmd.remove ( 'hydro' )
print InteractionButton[interaction]+'_'+InteractionName[interaction], 'resi ' + "+".join(selection)
del selection
with open(filename) as f:
f.readline()
#print 'here we go'
for line in f.readlines():
try:
#print line
resi= line.split()[0]
fp = line.split()[1:]
fp = ''.join(fp)
#print resi,fp
if fp != '000000000':
#print 'yes',fp
cmd.select('residue '+resi,'resi '+ resi)
cmd.show('sticks','resi '+ resi)
cmd.label('residue '+resi,'resi')
else:
#cmd.select('residue '+resi,'resi '+ resi)
#cmd.label('residue '+resi,'"no"')
#print 'no',fp
pass
except:
pass
except Exception, e:
print "Failed to open file %s\n%s" % (filename, e)
def findSurfaceResidues(objSel="(all)",
cutoff=2.5,
doShow=False,
verbose=False):
"""
findSurfaceResidues
finds those residues on the surface of a protein
that have at least 'cutoff' exposed A**2 surface area.
PARAMS
objSel (string)
the object or selection in which to find
exposed residues
DEFAULT: (all)
cutoff (float)
your cutoff of what is exposed or not.
DEFAULT: 2.5 Ang**2
asSel (boolean)
make a selection out of the residues found
RETURNS
(list: (chain, resv ) )
A Python list of residue numbers corresponding
to those residues w/more exposure than the cutoff.
"""
tmpObj = "__tmp"
cmd.create(tmpObj, objSel + " and polymer")
if verbose != False:
print "WARNING: I'm setting dot_solvent. You may not care for this."
cmd.set("dot_solvent")
cmd.get_area(selection=tmpObj, load_b=1)
# threshold on what one considers an "exposed" atom (in A**2):
cmd.remove(tmpObj + " and b < " + str(cutoff))
stored.tmp_dict = {}
cmd.iterate(tmpObj, "stored.tmp_dict[(chain,resv)]=1")
exposed = stored.tmp_dict.keys()
exposed.sort()
randstr = str(random.randint(0, 10000))
selName = "exposed_atm_" + randstr
if verbose != False:
print "Exposed residues are selected in: " + selName
cmd.select(selName, objSel + " in " + tmpObj)
selNameRes = "exposed_res_" + randstr
cmd.select(selNameRes, "byres " + selName)
if doShow != False:
cmd.show_as("spheres", objSel + " and poly")
cmd.color("white", objSel)
cmd.color("red", selName)
cmd.delete(tmpObj)
return exposed
def fetch_chain(code, name='', **kwargs):
if name == '':
name = code
chain = code[4] if len(code) == 5 else code[5]
r = fetch(code[:4], name, async=0, **kwargs)
if cmd.is_error(r):
return r
cmd.remove(name + ' and not chain ' + chain)
def test_get_seq():
cmd.reinitialize()
cmd.load(DATA_PATH / '2x19-frag-mse.pdb')
assert psico.modelling.get_seq("all") == "LSMMPD"
cmd.remove("resi 134")
assert psico.modelling.get_seq("all") == "LS/MPD"
cmd.alter("resi 137", "resn = 'XXX'")
assert psico.modelling.get_seq("all", unknown="#") == "LS/MP#"
def apply_symmetry(R, t, inchain, outchain):
cmd.copy('symm', f'inpdb')
coords = cmd.get_coords('symm')
cmd.remove(f'symm and not chain {inchain}')
coords_symm = (R.dot(coords.T)).T + t
cmd.load_coords(coords_symm, 'symm')
myspace = {'outchain': outchain}
cmd.alter('symm', 'chain=f"{outchain}"', space=myspace)
def test_stub2ala():
cmd.reinitialize()
cmd.fab('EFG', 'm1')
cmd.remove('not (backbone or name CB)')
psico.editing.stub2ala()
my_values = []
cmd.iterate('guide', 'my_values.append(resn)', space=locals())
assert my_values == ['ALA', 'ALA', 'GLY']
def fetch_chain(code, name='', **kwargs):
if name == '':
name = code
chain = code[4] if len(code) == 5 else code[5]
r = fetch(code[:4], name, async=0, **kwargs)
if cmd.is_error(r):
return r
cmd.remove(name + ' and not chain ' + chain)
def removeions():
cmd.select(
"Ions",
"((resn PO4) | (resn SO4) | (resn ZN) | (resn CA) | (resn MG) | (resn CL)) & hetatm"
)
cmd.remove("Ions")
cmd.delete("Ions")
return
def _do_mutation(self):
'''
After selection, propose what the fragment will look like where
applied.
Exception: _do_mutation should be wrapped in a try-exception block
when called
'''
cmd = self.cmd
cmd.delete(FRAG_NAME)
cmd.refresh_wizard()
if any(
cmd.count_atoms("(%s) & name %s" % (SRC_SELE, name)) != 1
for name in ("C1'", "C2'", "C3'", "C4'", "O4'")):
self.clear()
raise pymol.wizarding.WizardError(
'Improper selection of nucleic acid.')
frag_type_lower = self._mode_labels[self.mode].lower()
cmd.fragment(frag_type_lower, FRAG_NAME, origin=0)
self._update_reps()
cmd.color("white", "%s & elem C" % FRAG_NAME)
cmd.iterate("first (%s)" % SRC_SELE,
'stored.name = model+"/"+segi+"/"+chain+"/"+resn+"`"+resi',
space=self._space)
self.res_text = self._space['stored'].name
cmd.alter("?%s & name C1'" % SRC_SELE,
"stored.identifiers = (segi, chain, resi, ss, color)",
space=self._space)
self._status = Status.MUTAGENIZING
self.get_prompt()
cmd.iterate("(%s & name C1')" % SRC_SELE,
"stored.resn = resn",
space=self._space)
src_type_lower = self._space['stored'].resn.lower()
self._src_O_atom_name, self._src_Cp_atom_name, self._src_N_atom_name, \
self._src_C_atom_name = self._get_chi_dihedral_atoms(src_type_lower)
self._frag_O_atom_name, self._frag_Cp_atom_name, self._frag_N_atom_name, \
self._frag_C_atom_name = self._get_chi_dihedral_atoms(frag_type_lower)
cmd.pair_fit("(%s & name %s)" % (FRAG_NAME, self._frag_O_atom_name),
"(%s & name %s)" % (SRC_SELE, self._src_O_atom_name),
"(%s & name %s)" % (FRAG_NAME, self._frag_Cp_atom_name),
"(%s & name %s)" % (SRC_SELE, self._src_Cp_atom_name),
"(%s & name %s)" % (FRAG_NAME, self._frag_N_atom_name),
"(%s & name %s)" % (SRC_SELE, self._src_N_atom_name))
self._transfer_dihedral()
for a in self._sugar_phos_atoms:
cmd.remove("(%s & name %s)" % (FRAG_NAME, a))
if self._auto_center == "ON":
cmd.center(FRAG_NAME, animate=1)
def representation(mode='cartoon'):
cmd.bg_color('white')
cmd.remove('hydro')
if mode == 'cartoon':
ligand_cartoon()
elif mode == 'ribbon':
ligands()
elif mode == 'surface':
ligand_sites()
def adapt_for_peptides(self):
"""Adapt visualization for peptide ligands and interchain contacts"""
cmd.hide('sticks', self.ligname)
cmd.set('cartoon_color', 'lightorange', self.ligname)
cmd.show('cartoon', self.ligname)
cmd.show('sticks', "byres *-L")
cmd.util.cnc(self.ligname)
cmd.remove('%sCartoon and chain %s' % (self.protname, self.plcomplex.chain))
cmd.set('cartoon_side_chain_helper', 0)
def fSumWMCLast(molecule, SGNameAngle, chain, residue, MCNeighbour, DieElecMC, MCchargeN, MCchargeH, MCchargeProCA, MCchargeProCD, MCchargeProN, AmideName, printMC):
#print "Last", MCNeighbour
SumWMCLast = 0.0
SGnameselect = "/"+SGNameAngle+"//"+"/"+"/SG"
NBnameselect = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)
cmd.select("MC", NBnameselect)
MCpdbstr = cmd.get_pdbstr("MC")
MCsplit = MCpdbstr.split()
residueName = MCsplit[3]
#print NBnameselect, residueName
if residueName == "PRO":
### Proline CA
CAnameselect = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)+"/CA"
ResDist = cmd.dist(residue+'distLastProCA', SGnameselect,CAnameselect)
WMC = fWMC(MCchargeProCA, DieElecMC, ResDist)
SumWMCLast = SumWMCLast + WMC
if printMC == 'yes': print "MC ProCA ", MCNeighbour, " ", MCchargeProCA, " ", DieElecMC, " ", ResDist, " ", WMC
### Proline CD
CDnameselect = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)+"/CD"
ResDist = cmd.dist(residue+'distLastProCD', SGnameselect,CDnameselect)
WMC = fWMC(MCchargeProCD, DieElecMC, ResDist)
SumWMCLast = SumWMCLast + WMC
if printMC == 'yes': print "MC ProCD ", MCNeighbour, " ", MCchargeProCD, " ", DieElecMC, " ", ResDist, " ", WMC
### Proline N
Nnameselect = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)+"/N"
ResDist = cmd.dist(residue+'distLastProN', SGnameselect,Nnameselect)
WMC = fWMC(MCchargeProN, DieElecMC, ResDist)
SumWMCLast = SumWMCLast + WMC
if printMC == 'yes': print "MC ProN ", MCNeighbour, " ", MCchargeProN, " ", DieElecMC, " ", ResDist, " ", WMC
else:
AmideProt = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)+"/H01"
Hnameselect = "/"+AmideName+"//"+chain+"/"+str(MCNeighbour)+"/H01"
if cmd.count_atoms(AmideProt) == 0 and cmd.count_atoms(Hnameselect) == 0:
HbuildSelect = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)+"/N"
cmd.h_add(HbuildSelect)
cmd.create(AmideName, AmideName+" + "+AmideProt)
cmd.remove(AmideProt)
### Mainchain AmideH
ResDist = cmd.dist(residue+'distLastH', SGnameselect,Hnameselect)
WMC = fWMC(MCchargeH, DieElecMC, ResDist)
SumWMCLast = SumWMCLast + WMC
if printMC == 'yes': print "MC H ", MCNeighbour, " ", MCchargeH, " ", DieElecMC, " ", ResDist, " ", WMC
### Mainchain N
Nnameselect = "/"+molecule+"//"+chain+"/"+str(MCNeighbour)+"/N"
ResDist = cmd.dist(residue+'distLastN', SGnameselect,Nnameselect)
WMC = fWMC(MCchargeN, DieElecMC, ResDist)
SumWMCLast = SumWMCLast + WMC
if printMC == 'yes': print "MC N ", MCNeighbour, " ", MCchargeN, " ", DieElecMC, " ", ResDist, " ", WMC
cmd.delete(residue+'distLastProCA')
cmd.delete(residue+'distLastProCD')
cmd.delete(residue+'distLastProN')
cmd.delete(residue+'distLastH')
cmd.delete(residue+'distLastN')
cmd.show("nb_spheres", AmideName)
cmd.delete("MC")
return SumWMCLast
def surfaceatoms(molecule="NIL",show=True, verbose=True, cutoff=2.5):
"""
surfaceatoms
finds those residues on the surface of a protein
that have at least 'cutoff' exposed A**2 surface area.
PARAMS
molecule (string)
the object or selection in which to find
exposed residues
DEFAULT: (last molecule in pymol)
cutoff (float)
your cutoff of what is exposed or not.
DEFAULT: 2.5 Ang**2
RETURNS
(list: (chain, resv ) )
A Python list of residue numbers corresponding
to those residues w/more exposure than the cutoff.
"""
if molecule=="NIL":
assert len(cmd.get_names())!=0, "Did you forget to load a molecule? There are no objects in pymol."
molecule=cmd.get_names()[-1]
tmpObj="__tmp"
cmd.create(tmpObj, "(%s and polymer) and not resn HOH"%molecule)
if verbose!=False:
print "WARNING: I'm setting dot_solvent. You may not care for this."
cmd.set("dot_solvent")
cmd.get_area(selection=tmpObj, load_b=1)
# threshold on what one considers an "exposed" atom (in A**2):
cmd.remove( tmpObj + " and b < " + str(cutoff) )
stored.tmp_dict = {}
cmd.iterate(tmpObj, "stored.tmp_dict[(chain,resv)]=1")
exposed = stored.tmp_dict.keys()
exposed.sort()
selName = "%s_atoms"%molecule
cmd.select(selName, molecule + " in " + tmpObj )
if verbose!=False:
print "Exposed residues are selected in: " + selName
selNameRes = "%s_resi"%molecule
cmd.select(selNameRes, "byres " + selName )
if show!=False:
cmd.hide("everything", molecule)
cmd.show("cartoon", "%s and not %s and not resn HOH"%(molecule,selNameRes))
cmd.show("sticks", "%s"%selNameRes)
cmd.util.cbaw(selNameRes)
cmd.disable(selNameRes)
#cmd.alter('%s'%(selName),'vdw=0.5') # affects repeated runs
cmd.set('sphere_scale','0.3','%s'%(selName)) # does not affect repeated runs
cmd.show("spheres", "%s"%selName)
cmd.util.cbao(selName)
cmd.disable(selName)
cmd.delete(tmpObj)
print(exposed)
return(exposed)
def screenshotProteins():
# proteinsPath = ".\pdbs"
# set style parameters
# cmd.set("ray_opaque_background", 0)
# cmd.remove("solvent")
cmd.set("ambient", 0.3)
cmd.set("antialias", 1)
cmd.bg_color("white")
# cmd.set("direct", 1.0)
# cmd.set("ribbon_radius", 0.2)
# cmd.set("cartoon_highlight_color", "grey50")
# cmd.set("ray_trace_mode", 1)
# cmd.set("stick_radius", 0.2)
# cmd.set("mesh_radius", 0.02)
# loop thru folders
# for dir in os.walk(proteinsPath):
# proteinPath = dir[0]
# loop thru pdbs
# for file in os.listdir(proteinPath):
# if file.endswith('.pdb'):
csvFileName = "docked-protein-homomers.csv"
# to loop through csv
file = open(csvFileName, "r")
reader = csv.reader(file, delimiter=",")
k = 1
for row in reader:
for item in row:
print(k, item)
cmd.reinitialize()
# load the pdb file
cmd.fetch(item, path="./pdbs", type='pdb')
#pdbPath= "./pdbs/" + item + ".cif"
#cmd.load(pdbPath)
color = pickAColor()
cmd.color(color)
cmd.show("cartoon")
cmd.remove("solvent")
# take a screenshot
screenshotFileName = item + ".png"
screenshotPath = os.path.join('screenshots', screenshotFileName)
cmd.png(screenshotPath, 128, 128, ray=1)
# clear
cmd.delete("all")
k = k + 1
def get_coords(pdbfilename, object, device, selection=None):
if selection is None:
selection = f'{object} and name CA'
else:
selection = f'{object} and name CA and {selection}'
cmd.load(pdbfilename, object=object)
cmd.remove(f'not ({selection}) and {object}')
coords = cmd.get_coords(selection=object)
coords = torch.from_numpy(coords)
coords = coords.to(device)
return coords
def generate_grid(rna,
outname="test",
grid_size=2,
padding=2.0,
mindist=2.5,
maxdist=5.0,
debug=False):
# goto working directory
# setup 3D grid
extent = cmd.get_extent(selection=rna)
x = np.arange(extent[0][0] - padding, extent[1][0] + padding, grid_size)
y = np.arange(extent[0][1] - padding, extent[1][1] + padding, grid_size)
z = np.arange(extent[0][2] - padding, extent[1][2] + padding, grid_size)
xx, yy, zz = np.meshgrid(x, y, z)
nx, ny, nz = xx.shape[0], xx.shape[1], xx.shape[2]
# place pseudoatoms along grid
k = 1
for ix in tqdm(range(nx)):
for iy in range(ny):
for iz in range(nz):
cmd.pseudoatom("tmpPoint",
hetatm=1,
name="C",
resn="UNK",
resi=k,
chain="ZZ",
pos=[
float(xx[ix, iy, iz]),
float(yy[ix, iy, iz]),
float(zz[ix, iy, iz])
])
# prune
cmd.remove("resn UNK and resi %s within %s of polymer" %
(k, mindist))
cmd.remove("resn UNK and resi %s beyond %s of polymer" %
(k, maxdist))
# write out grid file
coor = "%s_grid.xyz" % (outname)
xyz = cmd.get_coords('tmpPoint', 1)
df = pd.DataFrame.from_records(xyz)
df.insert(0, "element", "C")
df.to_csv(coor, index=False, header=False, sep=" ")
# write out complex
cmd.create("complex", "%s tmpPoint" % rna)
coor = "%s_grid.pdb" % (outname)
cmd.save(coor, "complex")
if debug:
cmd.show("surface", "polymer")
cmd.show("spheres", "resn UNK")
def test(self):
cmd.set('suspend_undo')
cmd.fragment('gly', 'm1')
cmd.remove('not ID 0+1')
cmd.create('m1', 'm1', 1, 2)
cmd.rotate('x', 90, 'm1', 2)
steps = 5
cmd.morph('mout', 'm1', refinement=0, steps=steps, method='rigimol')
self.assertEqual(steps, cmd.count_states('mout'))
self.assertEqual(cmd.count_atoms('m1'),
cmd.count_atoms('mout'))
def test_update_identifiers():
cmd.reinitialize()
cmd.fab('ACD', 'm1')
cmd.fab('ACD', 'm2')
cmd.remove('m1 and not backbone')
cmd.alter('m1', '(segi, chain) = ("Segi", "Chain")')
psico.editing.update_identifiers('m2', 'm1', identifiers='segi chain')
assert cmd.get_chains('m2') == ['Chain']
my_values = []
cmd.iterate('m2', 'my_values.append(segi)', space=locals())
assert set(my_values) == set(["Segi"])
def testRegression2207(self):
'''
The initial fix for PYMOL-1697 crashed this example
(PYMOL-2207)
'''
cmd.load(self.datafile('1oky-frag.pdb'))
cmd.create('1oky-frag', 'resi 80-100', 1, 2)
cmd.remove('resi 85-95')
# keep ray efford low
cmd.viewport(50, 50)
# caused segfault
img = self.get_imagearray(ray=1)
def apply(self):
'''
Permanently applies the mutation upon the selected residue
Overrides method from Wizard class
'''
cmd = self.cmd
if self._status == Status.NO_SELECTION:
return
#Remove all atoms that are not in the sugar/phosphate group
#Needed for non-canonical bases
cmd.select("_tmp_sele_invert", "(none)")
for a in self._sugar_phos_atoms:
cmd.select("_tmp_sele_invert",
"_tmp_sele_invert | (%s & name %s)" % (SRC_SELE, a))
cmd.select("_tmp_sele_invert",
"%s and not _tmp_sele_invert" % SRC_SELE)
cmd.remove("_tmp_sele_invert")
try:
new_name = cmd.get_object_list(SRC_SELE)[0]
except IndexError:
print(" Mutagenesis: object not found.")
return
frag_name_three = self._mode_labels[self.mode]
frag_name_one = self._base3_to_1[frag_name_three.lower()]
# FUSE
cmd.fuse(
"%s & name %s" % (FRAG_NAME, self._frag_N_atom_name),
"/%s/%s/%s/%s & name %s" %
(new_name, self._stored.identifiers[0],
self._stored.identifiers[1], self._stored.identifiers[2],
self._src_Cp_atom_name), 1)
#Check to see if DNA
dnaPrefix = ''
if cmd.count_atoms("%s & name O2'" % SRC_SELE) == 0:
dnaPrefix = 'D'
cmd.alter(
"/%s/%s/%s/%s" %
(new_name, self._stored.identifiers[0],
self._stored.identifiers[1], self._stored.identifiers[2]),
"(resn) = '%s%s'" % (dnaPrefix, frag_name_one.upper()),
space=self._space)
cmd.unpick()
self.clear()
def fSumWMCresidue(molecule, SGNameAngle, chain, residue, MCNeighbour, DieElecMC, MCchargeC, MCchargeO, MCchargeN, MCchargeH, AmideName, printMC):
# print "residue", MCNeighbour
SumWMCresidue = 0.0
SGnameselect = "/" + SGNameAngle + "//" + "/" + "/SG"
NBnameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour)
cmd.select("MC", NBnameselect)
MCpdbstr = cmd.get_pdbstr("MC")
MCsplit = MCpdbstr.split()
residueName = MCsplit[3]
# print NBnameselect, residueName
AmideProt = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/H01"
Hnameselect = "/" + AmideName + "//" + chain + "/" + str(MCNeighbour) + "/H01"
if cmd.count_atoms(AmideProt) == 0 and cmd.count_atoms(Hnameselect) == 0:
HbuildSelect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/N"
cmd.h_add(HbuildSelect)
cmd.create(AmideName, AmideName + " + " + AmideProt)
cmd.remove(AmideProt)
# Mainchain AmideH
ResDist = cmd.dist(residue + 'distResH', SGnameselect, Hnameselect)
WMC = fWMC(MCchargeH, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC H ", MCNeighbour, " ", MCchargeH, " ", DieElecMC, " ", ResDist, " ", WMC)
# Mainchain C
Cnameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/C"
ResDist = cmd.dist(residue + 'distResC', SGnameselect, Cnameselect)
WMC = fWMC(MCchargeC, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC C ", MCNeighbour, " ", MCchargeC, " ", DieElecMC, " ", ResDist, " ", WMC)
# Mainchain O
Onameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/O"
ResDist = cmd.dist(residue + 'distResO', SGnameselect, Onameselect)
WMC = fWMC(MCchargeO, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC O ", MCNeighbour, " ", MCchargeO, " ", DieElecMC, " ", ResDist, " ", WMC)
# Mainchain N
Nnameselect = "/" + molecule + "//" + chain + "/" + str(MCNeighbour) + "/N"
ResDist = cmd.dist(residue + 'distResN', SGnameselect, Nnameselect)
WMC = fWMC(MCchargeN, DieElecMC, ResDist)
SumWMCresidue = SumWMCresidue + WMC
if printMC == 'yes':
print("MC N ", MCNeighbour, " ", MCchargeN, " ", DieElecMC, " ", ResDist, " ", WMC)
cmd.delete(residue + 'distResH')
cmd.delete(residue + 'distResC')
cmd.delete(residue + 'distResO')
cmd.delete(residue + 'distResN')
cmd.show("nb_spheres", AmideName)
cmd.delete("MC")
return SumWMCresidue
def polyala(selection='all', quiet=1):
'''
DESCRIPTION
Mutate any residue to Alanine (except Glycines)
SEE ALSO
stub2ala
'''
quiet = int(quiet)
cmd.remove('polymer and (%s) and not name C+N+O+CA+CB+OXT' % (selection))
cmd.alter('polymer and (%s) and not resn GLY' % (selection), 'resn = "ALA"')
cmd.sort()
def mark_res():
""" mark_res <pdb_file> <highlight_residue>
select the chain and residue that ICP dipeptide locate and highlight it.
"""
#list of pdb id, chain id, and residues informations for ICP. the lower case pdbs are from blast,
#upercase PDBs are from SGD pdb homologous search.
pdb_input_lists = [('1fa0', 'A', '177-178', '117-147'),
('1u5t', 'A', '42-43'),
('1yke', 'A', '103-104', '43-73'),
('2b1e', 'A', '294-295', '234-264'),
('2PFV', 'A', '294-295', '234-264'),
('1MNM', 'C', '177-178', '117-147'),
('2ckz', 'D', '11-12'),
('2pk9', 'D', '150-151+245-246', '90-120+185-215'),
('2pmi', 'D', '150-151+245-246', '90-120+185-215'),
('2xfv', 'A', '7-8'),
('3esl', 'A', '191-192', '131-161'),
('3n7n', 'E', '20-21'),
('3t5v', 'E', '288-289', '228-258'),
('4bh6', 'A', '365-366', '305-335')]
#iterate pdbs
for pdb_info in pdb_input_lists:
pdb_id = pdb_info[0]
chain_id = pdb_info[1]
res_id = pdb_info[2]
up_region = pdb_info[3] if len(pdb_info) == 4 else '0'
pdb_file = pdb_id + ".pdb"
chain_selection = "chain " + chain_id
res_selection = "res " + res_id
up_region_selection = "res " + up_region
#command chains to process the pdb files.
cmd.load(pdb_file)
cmd.remove("solvent")
cmd.color("gray80")
cmd.show("cartoon")
cmd.hide("line")
cmd.select("monomer", chain_selection)
cmd.color("cyan", "monomer")
cmd.select("icp_dipep", chain_selection + " and " + res_selection)
cmd.select("up_region", chain_selection + " and " + up_region_selection)
cmd.select("none")
cmd.color("red", "icp_dipep")
cmd.color("yellow", "up_region")
cmd.zoom(chain_selection)
# cmd.zoom("all")
cmd.png(pdb_id + ".png")
cmd.save(pdb_id + ".pse")
cmd.delete("all")
def testAtomLevelSettingsOnRemove2(self):
if cmd.get_setting_int('suspend_undo'):
self.skipTest("need suspend_undo=0")
cmd.load(self.datafile("1molecule.mae"))
cmd.load(self.datafile("1molecule.mae"))
cmd.label("index 10", "'Test Label'")
plv = [ 5., 0., 0.]
cmd.alter("index 10", "s.label_placement_offset = %s" % plv)
cmd.remove("index 10")
cmd.undo()
stored.offset = None
cmd.iterate("index 10", "stored.offset = list(s.label_placement_offset)")
self.assertEqual(stored.offset, plv)
