def unbond_close_hydrogen_bonds(selection='all'): """ DESCRIPTION Removes spurious chemical bonds between an amide hydrogen and an amide oxygen in a peptide/protein USAGE unbond_close_hydrogen_bonds [selection] ARGUMENTS selection: the selection to operate on, containing the acceptors and the hydrogens (defaults to 'all') NOTES Some molecular formats do not save bond information. In this case Pymol tries to guess bonds based on inter-atomic distances, which sometimes results in spurious bonds between atoms which lie too close. This function removes these bonds between a hydrogen bond acceptor and a hydrogen of a peptide bond. """ for oxygen in iterate_indices( '({}) and (e. O) and name O'.format(selection)): for hydrogen in iterate_indices( '({}) and (neighbor idx {}) and name HN and e. H'.format( selection, oxygen)): cmd.unbond('({}) and idx {}'.format(selection, oxygen), '({}) and idx {}'.format(selection, hydrogen))
def bond_zns(sel): cmd.unbond(sel + " and resn ZNS", sel + " and not resn ZNS") # for c,i in getres("resn ZNS"): # cmd.bond(sel+" and chain %s and resi %i and name ZN1"%(c,i), # sel+" and chain %s and resi %i and name S*"%(c,i)) for c, i in getres("name ZN1"): cmd.bond(sel + " and chain %s and resi %i and name ZN1" % (c, i), sel + " and chain %s and resi %i and name S*,N2,N4" % (c, i)) allsg = cmd.get_model(sel + " and (resn CYS and (name CB))").atom allsf = cmd.get_model(sel + " and (resn ZHC and (name S*,C1,C4))").atom while allsg: closest = [9e9, None, None] for sga in allsg: for sfa in allsf: sg = Vec(sga.coord) sf = Vec(sfa.coord) if (sg - sf).length() < closest[0]: closest = [(sg - sf).length(), sga, sfa] sga, sfa = closest[1:] allsg.remove(sga) allsf.remove(sfa) if closest[0] > 10.0: break cmd.bond( sel + " and resi %s and chain %s and name %s" % (sga.resi, sga.chain, sga.name), sel + " and resi %s and chain %s and name %s" % (sfa.resi, sfa.chain, sfa.name))
def bond_zns(sel): cmd.unbond(sel + " and resn ZNS", sel + " and not resn ZNS") # for c, i in getres("resn ZNS"): # cmd.bond(sel+" and chain %s and resi %i and name ZN1"%(c, i), # sel+" and chain %s and resi %i and name S*"%(c, i)) for c, i in getres("name ZN1"): cmd.bond( sel + " and chain %s and resi %i and name ZN1" % (c, i), sel + " and chain %s and resi %i and name S*, N2, N4" % (c, i), ) allsg = cmd.get_model(sel + " and (resn CYS and (name CB))").atom allsf = cmd.get_model(sel + " and (resn ZHC and (name S*, C1, C4))").atom while allsg: closest = [9e9, None, None] for sga in allsg: for sfa in allsf: sg = Vec(sga.coord) sf = Vec(sfa.coord) if (sg - sf).length() < closest[0]: closest = [(sg - sf).length(), sga, sfa] sga, sfa = closest[1:] allsg.remove(sga) allsf.remove(sfa) if closest[0] > 10.0: break cmd.bond( sel + " and resi %s and chain %s and name %s" % (sga.resi, sga.chain, sga.name), sel + " and resi %s and chain %s and name %s" % (sfa.resi, sfa.chain, sfa.name), )
def testRepsExist(self): cmd.viewport(200, 150) cmd.load(self.datafile('1oky-frag.pdb'), 'm1') # make some nonbonded cmd.unbond('resi 115-', 'resi 115-') # labels cmd.label('all', 'name') # measurements cmd.distance('measure1', 'index 1', 'index 10') cmd.angle('measure1', 'index 1', 'index 10', 'index 20') cmd.dihedral('measure1', 'index 1', 'index 10', 'index 20', 'index 30') # color test setup cmd.color('white', '*') cmd.set('ambient', 1) cmd.set('depth_cue', 0) cmd.set('antialias', 0) cmd.set('line_smooth', 0) cmd.orient() # test most reps for rep in REPS: cmd.show_as(rep) self.assertImageHasColor('white', msg='rep missing: ' + rep) # test cartoon cmd.show_as('cartoon') for cart in CARTOONS: cmd.cartoon(cart) self.assertImageHasColor('white', msg='cartoon missing: ' + cart)
def untangle_sidechains(sele): for c, i in getres(sele): if c != "": cmd.unbond( "%s and resi %i and chain %s and not name N+C" % (sele, i, c), "not (%s and resi %i and chain %s)" % (sele, i, c), ) else: cmd.unbond( "%s and resi %i and not name N+C" % (sele, i), "not (%s and resi %i )" % (sele, i), )
def test_bond(self): cmd.pseudoatom('m1', pos=(0, 0, 0)) cmd.pseudoatom('m1', pos=(1, 0, 0)) cmd.pseudoatom('m1', pos=(1, 1, 0)) cmd.bond('m1`1', 'm1`2') count = cmd.count_atoms('(m1`1) extend 1') self.assertEqual(count, 2) cmd.unbond('m1`1', 'm1`2') count = cmd.count_atoms('(m1`1) extend 1') self.assertEqual(count, 1)
def test_bond(self): cmd.pseudoatom('m1', pos=(0,0,0)) cmd.pseudoatom('m1', pos=(1,0,0)) cmd.pseudoatom('m1', pos=(1,1,0)) cmd.bond('m1`1', 'm1`2') count = cmd.count_atoms('(m1`1) extend 1') self.assertEqual(count, 2) cmd.unbond('m1`1', 'm1`2') count = cmd.count_atoms('(m1`1) extend 1') self.assertEqual(count, 1)
def test(self): cmd.set('cartoon_gap_cutoff', 0) # default varies by version self.ambientOnly() cmd.viewport(150, 150) cmd.load(self.datafile('1oky-frag.pdb')) cmd.cartoon('dash') cmd.show_as('cartoon') cmd.orient() # no gaps img_nogaps = self.get_imagearray() # gap of length 0 cmd.unbond('96/C', '97/N') img_gap = self.get_imagearray() self.assertFalse((img_gap == img_nogaps).all()) # close gap with setting, should match first image (special case) cmd.set('cartoon_gap_cutoff', 1) # exact cutoff img_gap = self.get_imagearray() self.assertTrue((img_gap == img_nogaps).all()) # gap of length 1 cmd.remove('92/') img_gap = self.get_imagearray() cmd.set('cartoon_gap_cutoff', 2) # exact cutoff img_nogaps = self.get_imagearray() self.assertFalse((img_gap == img_nogaps).all()) # gap of length 3 cmd.remove('102-104/') cmd.cartoon('auto') # default img_gap = self.get_imagearray() cmd.set('cartoon_gap_cutoff', 10) # arbitrary larger cutoff img_nogaps = self.get_imagearray() self.assertFalse((img_gap == img_nogaps).all())
def create_object_with_flipkin_coords(mpobj, which_flips='NQ'): '''Duplicate the mpobj molecule and apply the flipNQ/H group coordinates. PARAMETERS mpobj An MPObject instance which_flips Either 'NQ' or 'H' to specify which flipkin to use ''' flipkin_name = 'flipkin{}'.format(which_flips) flipkin = mpobj.kin[flipkin_name] flip_group = 'flip{}'.format(which_flips) reduced_obj = mpobj.pdb['reduce'] flipped_obj = mpobj.pdb[flipkin_name] cmd.create(flipped_obj, reduced_obj) for vl in flipkin.vectorlists(): # Skip if not coordinates if vl[0].vectorlist_name == 'x': msg = 'skipping non-coords vectorlist {}' logger.debug(msg.format(vl[0].vectorlist_name)) continue # Skip everything except the'flipNQ' (or 'flipH') group if vl[0].group[0] != flip_group: msg = 'skipping non-{} vectorlist'.format(flip_group) logger.debug(msg) continue logger.debug('begin flipping vectorlist') for v in vl: if not (v.atom[0] and v.atom[1]): msg = 'vector {} was missing atoms: {}'.format(v, v.atom) logger.warning(msg) continue macro = v.macro(1) sel = v.sel(1) logger.debug('atom to be flipped: {}\n sel: {}'.format(macro, sel)) source_coords = v.coords[1] target_sel = '{} and {}'.format(flipped_obj, sel) msg = 'flipping atom {} to {}'.format(target_sel, source_coords) logger.debug(msg) ret = cmd.load_coords([source_coords], target_sel) if ret == -1: success = 0 a = v.atom[1] if a['resn'] == 'HIS': his_h = { 'HD1': { 'old_h': 'HE2', 'old_n': 'NE2', 'new_h': 'HD1', 'new_n': 'ND1', }, 'HE2': { 'old_h': 'HD1', 'old_n': 'ND1', 'new_h': 'HE2', 'new_n': 'NE2', } } if a['name'] in his_h.keys(): # Reduce has switched which N is protonated. Let's move # the old H atom and rename it. resi_sel = '{} and chain {} and resi {}'.format( flipped_obj, a['chain'], a['resi']) h = his_h[a['name']] old_h = '{} and name {}'.format(resi_sel, h['old_h']) old_n = '{} and name {}'.format(resi_sel, h['old_n']) new_h = '{} and name {}'.format(resi_sel, h['new_h']) new_n = '{} and name {}'.format(resi_sel, h['new_n']) # Break the old bond cmd.unbond(old_h, old_n) # Rename the atom cmd.alter(old_h, 'name="{}"'.format(a['name'])) # Make the new bond cmd.bond(new_h, new_n) # Retry loading coordinates ret = cmd.load_coords([source_coords], target_sel) if not ret == -1: success = 1 if not success: msg = 'failed to load coords for {}!'.format(macro) logger.warning(msg) logger.debug('end flipping vectorlist')
def fix_bonds(selection): stored.residues = [] cmd.iterate(selection + ' and n. ca', 'stored.residues.append((resi,resn))') last_residue = stored.residues[-1][0] print(last_residue) for r1 in range(len(stored.residues)): residue1 = selection + " and r. " + stored.residues[r1][ 1] + " and i. " + stored.residues[r1][0] sele1 = residue1 + " and n. ca+c+c+o+n" sele2 = residue1 + " and !n. ca+c+c+o+n+cb" print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) for r2 in range(r1 + 1, len(stored.residues)): residue2 = selection + " and r. " + stored.residues[r2][ 1] + " and i. " + stored.residues[r2][0] if int(stored.residues[r1][0]) != int(stored.residues[r2][0]): sele1 = residue1 sele2 = residue2 print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) if int(stored.residues[r2][0]) == (int(stored.residues[r1][0]) + 1): sele1 = residue1 + " and n. c" sele2 = residue2 + " and n. n" print("bond ", sele1, ",", sele2) cmd.bond(sele1, sele2) # FIX RESIDUE SIDE CHAIN if stored.residues[r1][1] == "PRO": sele1 = residue1 + " and n. n" sele2 = residue1 + " and n. cd" print("bond ", sele1, ",", sele2) cmd.bond(sele1, sele2) elif stored.residues[r1][1] == "THR": sele1 = residue1 + " and !n. ca+og1+cg2+cb" sele2 = residue1 + " and n. cb" print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) elif stored.residues[r1][1] == "ILE" or stored.residues[r1][1] == "VAL": for resitype in ["ILE", "VAL"]: sele1 = residue1 + " and !n. ca+cg1+cg2+cb" sele2 = residue1 + " and n. cb" print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) elif stored.residues[r1][1] == "SER": sele1 = residue1 + " and !n. ca+og+cb" sele2 = residue1 + " and n. cb" print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) elif stored.residues[r1][1] == "CYS": sele1 = residue1 + " and !n. ca+sg+cb" sele2 = residue1 + " and n. cb" print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) else: sele1 = residue1 + " and !n. ca+cg+cb" sele2 = residue1 + " and n. cb" print("unbond ", sele1, ",", sele2) cmd.unbond(sele1, sele2) # FIX CENTROID LEVEL sele1 = residue1 + " and n. cen" sele2 = residue1 + " and n. cb" print("bond ", sele1, ",", sele2) cmd.bond(sele1, sele2) # FIX C-TERMINAL if stored.residues[r1][0] == last_residue: sele1 = residue1 + " and n. c" sele2 = residue1 + " and n. oxt" print("bond ", sele1, ",", sele2) cmd.bond(sele1, sele2) stored.cys = [] cmd.iterate(selection + ' and r. CYS and n. cb', 'stored.cys.append((resi,resn))') if len(stored.cys) >= 2: for r1 in range(len(stored.cys)): for r2 in range(r1 + 1, len(stored.cys)): if stored.cys[r1][0] != stored.cys[r2][0]: sele1 = selection + " and i. " + stored.cys[r1][ 0] + " and n. cb" sele2 = selection + " and i. " + stored.cys[r2][ 0] + " and n. cb" dist = cmd.distance("tmpdist", sele1, sele2) if dist < 4.0: print(dist, sele1, ",", sele2) sele1 = selection + " and i. " + stored.cys[r1][ 0] + " and n. sg" sele2 = selection + " and i. " + stored.cys[r2][ 0] + " and n. sg" print("bond ", sele1, ",", sele2) cmd.bond(sele1, sele2) cmd.delete("tmpdist")
def create_object_with_flipkin_coords(mpobj, which_flips='NQ'): '''Duplicate the mpobj molecule and apply the flipNQ/H group coordinates. PARAMETERS mpobj An MPObject instance which_flips Either 'NQ' or 'H' to specify which flipkin to use ''' flipkin_name = 'flipkin{}'.format(which_flips) flipkin = mpobj.kin[flipkin_name] flip_group = 'flip{}'.format(which_flips) reduced_obj = mpobj.pdb['reduce'] flipped_obj = mpobj.pdb[flipkin_name] cmd.create(flipped_obj, reduced_obj) for vl in flipkin.vectorlists(): # Skip if not coordinates if vl[0].vectorlist_name == 'x': msg = 'skipping non-coords vectorlist {}' logger.debug(msg.format(vl[0].vectorlist_name)) continue # Skip everything except the'flipNQ' (or 'flipH') group if vl[0].group[0] != flip_group: msg = 'skipping non-{} vectorlist'.format(flip_group) logger.debug(msg) continue logger.debug('begin flipping vectorlist') for v in vl: if not (v.atom[0] and v.atom[1]): msg = 'vector {} was missing atoms: {}'.format(v, v.atom) logger.warning(msg) continue macro = v.macro(1) sel = v.sel(1) logger.debug('atom to be flipped: {}\n sel: {}'.format( macro, sel)) source_coords = v.coords[1] target_sel = '{} and {}'.format(flipped_obj, sel) msg = 'flipping atom {} to {}'.format(target_sel, source_coords) logger.debug(msg) ret = cmd.load_coords([source_coords], target_sel) if ret == -1: success = 0 a = v.atom[1] if a['resn'] == 'HIS': his_h = { 'HD1': { 'old_h': 'HE2', 'old_n': 'NE2', 'new_h': 'HD1', 'new_n': 'ND1', }, 'HE2': { 'old_h': 'HD1', 'old_n': 'ND1', 'new_h': 'HE2', 'new_n': 'NE2', } } if a['name'] in his_h.keys(): # Reduce has switched which N is protonated. Let's move # the old H atom and rename it. resi_sel = '{} and chain {} and resi {}'.format( flipped_obj, a['chain'], a['resi']) h = his_h[a['name']] old_h = '{} and name {}'.format(resi_sel, h['old_h']) old_n = '{} and name {}'.format(resi_sel, h['old_n']) new_h = '{} and name {}'.format(resi_sel, h['new_h']) new_n = '{} and name {}'.format(resi_sel, h['new_n']) # Break the old bond cmd.unbond(old_h, old_n) # Rename the atom cmd.alter(old_h, 'name="{}"'.format(a['name'])) # Make the new bond cmd.bond(new_h, new_n) # Retry loading coordinates ret = cmd.load_coords([source_coords], target_sel) if not ret == -1: success = 1 if not success: msg = 'failed to load coords for {}!'.format(macro) logger.warning(msg) logger.debug('end flipping vectorlist')
def do_library(self): cmd=self.cmd pymol=cmd._pymol if not ((cmd.count_atoms("(%s) and name N"%src_sele)==1) and (cmd.count_atoms("(%s) and name C"%src_sele)==1) and (cmd.count_atoms("(%s) and name O"%src_sele)==1)): self.clear() return 1 cmd.feedback("push") cmd.feedback("disable","selector","everythin") cmd.feedback("disable","editor","actions") self.prompt = [ 'Loading rotamers...'] self.bump_scores = [] state_best = 0 pymol.stored.name = 'residue' cmd.iterate("first (%s)"%src_sele,'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi') self.res_text = pymol.stored.name cmd.select("_seeker_hilight",src_sele) auto_zoom = cmd.get_setting_text('auto_zoom') cmd.set('auto_zoom',"0",quiet=1) cmd.frame(0) cmd.delete(frag_name) if self.auto_center: cmd.center(src_sele,animate=-1) self.lib_mode = self.mode if self.lib_mode=="current": pymol.stored.resn="" cmd.iterate("(%s & name CA)"%src_sele,"stored.resn=resn") rot_type = _rot_type_xref.get(pymol.stored.resn,pymol.stored.resn) if (self.c_cap!='none') or (self.n_cap!='none') or (self.hyd != 'auto'): self.lib_mode = rot_type # force fragment-based load else: cmd.create(frag_name,src_sele,1,1) if self.c_cap=='open': cmd.remove("%s and name OXT"%frag_name) if self.lib_mode!='current': rot_type = self.lib_mode frag_type = self.lib_mode if (self.n_cap == 'posi') and (frag_type[0:3]!='NT_'): if not ( cmd.count_atoms( "elem C & !(%s) & (bto. (name N & (%s))) &! resn ACE"% (src_sele,src_sele))): # use N-terminal fragment frag_type ="NT_"+frag_type if (self.c_cap == 'nega') and (frag_type[0:3]!='CT_'): if not ( cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"% (src_sele,src_sele))): # use C-terminal fragment frag_type ="CT_"+frag_type if rot_type[0:3] in [ 'NT_', 'CT_' ]: rot_type = rot_type[3:] rot_type = _rot_type_xref.get(rot_type, rot_type) cmd.fragment(frag_type.lower(), frag_name, origin=0) # trim off hydrogens if (self.hyd == 'none'): cmd.remove("("+frag_name+" and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("("+src_sele+") and hydro")==0: cmd.remove("("+frag_name+" and hydro)") # copy identifying information cmd.alter("?%s & name CA" % src_sele, "stored.identifiers = (segi, chain, resi, ss, color)", space=self.space) cmd.alter("?%s" % frag_name, "(segi, chain, resi, ss) = stored.identifiers[:4]", space=self.space) # move the fragment if ((cmd.count_atoms("(%s & name CB)"%frag_name)==1) and (cmd.count_atoms("(%s & name CB)"%src_sele)==1)): cmd.pair_fit("(%s & name CA)"%frag_name, "(%s & name CA)"%src_sele, "(%s & name CB)"%frag_name, "(%s & name CB)"%src_sele, "(%s & name C)"%frag_name, "(%s & name C)"%src_sele, "(%s & name N)"%frag_name, "(%s & name N)"%src_sele) else: cmd.pair_fit("(%s & name CA)"%frag_name, "(%s & name CA)"%src_sele, "(%s & name C)"%frag_name, "(%s & name C)"%src_sele, "(%s & name N)"%frag_name, "(%s & name N)"%src_sele) # fix the carbonyl position... cmd.iterate_state(1,"(%s & name O)"%src_sele,"stored.list=[x,y,z]") cmd.alter_state(1,"(%s & name O)"%frag_name,"(x,y,z)=stored.list") if cmd.count_atoms("(%s & name OXT)"%src_sele): cmd.iterate_state(1,"(%s & name OXT)"%src_sele,"stored.list=[x,y,z]") cmd.alter_state(1,"(%s & name OXT)"%frag_name,"(x,y,z)=stored.list") elif cmd.count_atoms("(%s & name OXT)"%frag_name): # place OXT if no template exists angle = cmd.get_dihedral("(%s & name N)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name C)"%frag_name, "(%s & name O)"%frag_name) cmd.protect("(%s & name O)"%frag_name) cmd.set_dihedral("(%s & name N)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name C)"%frag_name, "(%s & name OXT)"%frag_name,180.0+angle) cmd.deprotect(frag_name) # fix the hydrogen position (if any) if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%frag_name)==1: if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%src_sele)==1: cmd.iterate_state(1,"(hydro and bound_to (name N & (%s)))"%src_sele, "stored.list=[x,y,z]") cmd.alter_state(1,"(hydro and bound_to (name N & (%s)))"%frag_name, "(x,y,z)=stored.list") elif cmd.select(tmp_sele1,"(name C & bound_to (%s and elem N))"%src_sele)==1: # position hydro based on location of the carbonyl angle = cmd.get_dihedral("(%s & name C)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name N)"%frag_name, tmp_sele1) cmd.set_dihedral("(%s & name C)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name N)"%frag_name, "(%s & name H)"%frag_name,180.0+angle) cmd.delete(tmp_sele1) # add c-cap (if appropriate) if self.c_cap in [ 'amin', 'nmet' ]: if not cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"% (src_sele,src_sele)): if cmd.count_atoms("name C & (%s)"%(frag_name))==1: if self.c_cap == 'amin': editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nhh') elif self.c_cap == 'nmet': editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nme') if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name): cmd.h_fix("name N & bound_to (name C & (%s))"%frag_name) # trim hydrogens if (self.hyd == 'none'): cmd.remove("("+frag_name+" and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("("+src_sele+") and hydro")==0: cmd.remove("("+frag_name+" and hydro)") # add n-cap (if appropriate) if self.n_cap in [ 'acet' ]: if not cmd.count_atoms("elem C & !(%s) & (bto. (name N & (%s))) & !resn ACE "% (src_sele,src_sele)): if cmd.count_atoms("name N & (%s)"%(frag_name))==1: if self.n_cap == 'acet': editor.attach_amino_acid("name N & (%s)"%(frag_name), 'ace') if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name): cmd.h_fix("name N & (%s)"%frag_name) # trim hydrogens if (self.hyd == 'none'): cmd.remove("("+frag_name+" and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("("+src_sele+") and hydro")==0: cmd.remove("("+frag_name+" and hydro)") cartoon = (cmd.count_atoms("(%s & name CA & rep cartoon)"%src_sele)>0) sticks = (cmd.count_atoms("(%s & name CA & rep sticks)"%src_sele)>0) cmd.delete(obj_name) key = rot_type lib = None if self.dep == 'dep': try: result = cmd.phi_psi("%s"%src_sele) if len(result)==1: (phi,psi) = list(result.values())[0] (phi,psi) = (int(10*round(phi/10)),int(10*(round(psi/10)))) key = (rot_type,phi,psi) if key not in self.dep_library: (phi,psi) = (int(20*round(phi/20)),int(20*(round(psi/20)))) key = (rot_type,phi,psi) if key not in self.dep_library: (phi,psi) = (int(60*round(phi/60)),int(60*(round(psi/60)))) key = (rot_type,phi,psi) lib = self.dep_library.get(key,None) except: pass if lib == None: key = rot_type lib = self.ind_library.get(key,None) if (lib!= None) and self.dep == 'dep': print(' Mutagenesis: no phi/psi, using backbone-independent rotamers.') if lib != None: state = 1 for a in lib: cmd.create(obj_name,frag_name,1,state) if state == 1: cmd.select(mut_sele,"(byres (%s like %s))"%(obj_name,src_sele)) if rot_type=='PRO': cmd.unbond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele) for b in a.keys(): if b!='FREQ': cmd.set_dihedral("(%s & n;%s)"%(mut_sele,b[0]), "(%s & n;%s)"%(mut_sele,b[1]), "(%s & n;%s)"%(mut_sele,b[2]), "(%s & n;%s)"%(mut_sele,b[3]), a[b],state=state) else: cmd.set_title(obj_name,state,"%1.1f%%"%(a[b]*100)) if rot_type=='PRO': cmd.bond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele) state = state + 1 cmd.delete(frag_name) print(" Mutagenesis: %d rotamers loaded."%len(lib)) if self.bump_check: cmd.delete(bump_name) cmd.create(bump_name, "(((byobj %s) within 6 of (%s and not name N+C+CA+O+H+HA)) and (not (%s)))|(%s)"% (src_sele,mut_sele,src_sele,mut_sele),singletons=1) cmd.color("gray50",bump_name+" and elem C") cmd.set("seq_view",0,bump_name,quiet=1) cmd.hide("everything",bump_name) if ((cmd.select(tmp_sele1, "(name N & (%s in (neighbor %s)))"% (bump_name,src_sele)) == 1) and (cmd.select(tmp_sele2, "(name C & (%s in %s))"% (bump_name,mut_sele)) == 1)): cmd.bond(tmp_sele1,tmp_sele2) if ((cmd.select(tmp_sele1,"(name C & (%s in (neighbor %s)))"% (bump_name,src_sele)) == 1) and (cmd.select(tmp_sele2,"(name N & (%s in %s))"% (bump_name,mut_sele)) == 1)): cmd.bond(tmp_sele1,tmp_sele2) cmd.delete(tmp_sele1) cmd.delete(tmp_sele2) cmd.protect("%s and not (%s in (%s and not name N+C+CA+O+H+HA))"% (bump_name,bump_name,mut_sele)) cmd.sculpt_activate(bump_name) cmd.show("cgo",bump_name) # draw the bumps cmd.set("sculpt_vdw_vis_mode",1,bump_name) state = 1 score_best = 1e6 for a in lib: score = cmd.sculpt_iterate(bump_name, state, 1) self.bump_scores.append(score) if score < score_best: state_best = state score_best = score state = state + 1 cmd.delete(mut_sele) else: cmd.create(obj_name,frag_name,1,1) print(" Mutagenesis: no rotamers found in library.") cmd.set("seq_view",0,obj_name,quiet=1) pymol.util.cbaw(obj_name) cmd.hide("("+obj_name+")") cmd.show(self.rep,obj_name) cmd.show('lines',obj_name) #neighbor always show lines if cartoon: cmd.show("cartoon",obj_name) if sticks: cmd.show("sticks",obj_name) cmd.set('auto_zoom',auto_zoom,quiet=1) cmd.delete(frag_name) cmd.frame(state_best) cmd.unpick() cmd.feedback("pop")
def load_ff(filename): """ Load a fDynamo force field file (.ff) Re-bond ligands accordingly Alter properties of all atoms: - 'text_type' : atomtypes - 'partial_charges' : charges Parameters ---------- filename : str file path """ print(f" pyDYNAMON: reading \"{filename}\"") # residue names excluded from re-bonding rebond_excluded = [] rebond_excluded.extend(aa_dict.keys()) rebond_excluded.extend(["SOL", "NA", "CL"]) # read file as list of strings with open(filename, "rt") as f: ff_file = f.readlines() # remove comment lines and blank lines ff_file = [ line.strip() for line in ff_file if line.strip() and not line.startswith("!") ] # read residue atoms and bonds topology = dict() current_sect = None for line in ff_file: line = line.split("!") keyword = line[0].split()[0].lower() content = line[0].split() if keyword == 'end': current_sect = None elif keyword == 'residues': current_sect = keyword elif current_sect == 'residues' or keyword == 'residue': if keyword == 'residue': # new residue current_sect = 'residues' resname = content[1] topology[resname] = dict() continue top = topology[resname] if not topology[resname]: # first line (numbers) top['natoms'] = int(content[0]) top['nbonds'] = int(content[1]) top['nimpropers'] = int(content[2]) top['atoms'] = dict() top['bonds'] = [] top['impropers'] = [] elif len(top['atoms']) < top['natoms']: param = { 'atomtype': str(content[1]).upper(), 'charge': float(content[2]) } top['atoms'][str(content[0]).upper()] = param elif len(top['bonds']) < top['nbonds']: bonds = [(b.split()[0].upper(), b.split()[1].upper()) for b in " ".join(content).split(";") if b.strip()] top['bonds'].extend(bonds) elif len(top['impropers']) < top['nimpropers']: impropers = [(i.split()[0].upper(), i.split()[1].upper(), i.split()[2].upper(), i.split()[3].upper()) for i in " ".join(content).split(";") if i.strip()] top['impropers'].extend(impropers) for resname, top in topology.items(): # atomtypes and partial charges for name, param in top['atoms'].items(): cmd.alter(f"resn {resname} & name {name}", f"partial_charge={param['charge']}") cmd.alter(f"resn {resname} & name {name}", f"text_type=\'{param['atomtype']}\'") # unbond all and re-bond if resname in rebond_excluded: continue cmd.unbond(f"resn {resname}", f"resn {resname}") for bond in top['bonds']: cmd.bond(f"resn {resname} & name {bond[0]}", f"resn {resname} & name {bond[1]}")
CTERM_tuple: [CTERM_bonds_all, CTERM_bonds_double], ARG_tuple: [ARG_bonds_all, ARG_bonds_double] } if bonds != 2: lines = 4 print "Formating as delocalized bonds" else: lines = 1 print "Formating as double bonds" # for all tuples (i.e format_dict.keys()) for p in format_dict.keys(): # go through list except ID at pos 1 for q in p[1:]: # format bonds for r in format_dict[p][0]: cmd.unbond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1])) cmd.bond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1]), lines) if lines == 1: # add double bonds for r in format_dict[p][1]: cmd.unbond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1])) cmd.bond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1]), 2) return bonds cmd.extend("format_bonds", format_bonds) cmd.auto_arg[0]['format_bonds'] = [lambda: cmd.Shortcut(['all', 'resn PHE+TYR+PTR+NIY+PNIY+TRP+NIW+HIS', 'resn GLU+ASP', 'resn ARG', 'last all']), 'selection=', ', '] cmd.auto_arg[1]['format_bonds'] = [lambda: cmd.Shortcut(['4', '2', '1']), 'bonds=', ''] ################################################################################
def do_library(self): cmd=self.cmd pymol=cmd._pymol if not ((cmd.count_atoms("(%s) and name N"%src_sele)==1) and (cmd.count_atoms("(%s) and name C"%src_sele)==1) and (cmd.count_atoms("(%s) and name O"%src_sele)==1)): self.clear() return 1 cmd.feedback("push") cmd.feedback("disable","selector","everythin") cmd.feedback("disable","editor","actions") self.prompt = [ 'Loading rotamers...'] self.bump_scores = [] state_best = 0 pymol.stored.name = 'residue' cmd.iterate("first (%s)"%src_sele,'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi') self.res_text = pymol.stored.name cmd.select("_seeker_hilight",src_sele) auto_zoom = cmd.get_setting_text('auto_zoom') cmd.set('auto_zoom',"0",quiet=1) cmd.frame(0) cmd.delete(frag_name) if self.auto_center: cmd.center(src_sele,animate=-1) self.lib_mode = self.mode if self.lib_mode=="current": pymol.stored.resn="" cmd.iterate("(%s & name CA)"%src_sele,"stored.resn=resn") rot_type = _rot_type_xref.get(pymol.stored.resn,pymol.stored.resn) if (self.c_cap!='none') or (self.n_cap!='none') or (self.hyd != 'auto'): self.lib_mode = rot_type # force fragment-based load else: cmd.create(frag_name,src_sele,1,1) if self.c_cap=='open': cmd.remove("%s and name OXT"%frag_name) if self.lib_mode!='current': rot_type = self.lib_mode frag_type = self.lib_mode if (self.n_cap == 'posi') and (frag_type[0:3]!='NT_'): if not ( cmd.count_atoms( "elem C & !(%s) & (bto. (name N & (%s))) &! resn ACE"% (src_sele,src_sele))): # use N-terminal fragment frag_type ="NT_"+frag_type if (self.c_cap == 'nega') and (frag_type[0:3]!='CT_'): if not ( cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"% (src_sele,src_sele))): # use C-terminal fragment frag_type ="CT_"+frag_type if rot_type[0:3] in [ 'NT_', 'CT_' ]: rot_type = rot_type[3:] rot_type = _rot_type_xref.get(rot_type, rot_type) cmd.fragment(frag_type.lower(), frag_name, origin=0) # trim off hydrogens if (self.hyd == 'none'): cmd.remove("("+frag_name+" and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("("+src_sele+") and hydro")==0: cmd.remove("("+frag_name+" and hydro)") # copy identifying information cmd.alter("?%s & name CA" % src_sele, "stored.identifiers = (segi, chain, resi, ss, color)", space=self.space) cmd.alter("?%s" % frag_name, "(segi, chain, resi, ss) = stored.identifiers[:4]", space=self.space) # move the fragment if ((cmd.count_atoms("(%s & name CB)"%frag_name)==1) and (cmd.count_atoms("(%s & name CB)"%src_sele)==1)): cmd.pair_fit("(%s & name CA)"%frag_name, "(%s & name CA)"%src_sele, "(%s & name CB)"%frag_name, "(%s & name CB)"%src_sele, "(%s & name C)"%frag_name, "(%s & name C)"%src_sele, "(%s & name N)"%frag_name, "(%s & name N)"%src_sele) else: cmd.pair_fit("(%s & name CA)"%frag_name, "(%s & name CA)"%src_sele, "(%s & name C)"%frag_name, "(%s & name C)"%src_sele, "(%s & name N)"%frag_name, "(%s & name N)"%src_sele) # fix the carbonyl position... cmd.iterate_state(1,"(%s & name O)"%src_sele,"stored.list=[x,y,z]") cmd.alter_state(1,"(%s & name O)"%frag_name,"(x,y,z)=stored.list") if cmd.count_atoms("(%s & name OXT)"%src_sele): cmd.iterate_state(1,"(%s & name OXT)"%src_sele,"stored.list=[x,y,z]") cmd.alter_state(1,"(%s & name OXT)"%frag_name,"(x,y,z)=stored.list") elif cmd.count_atoms("(%s & name OXT)"%frag_name): # place OXT if no template exists angle = cmd.get_dihedral("(%s & name N)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name C)"%frag_name, "(%s & name O)"%frag_name) cmd.protect("(%s & name O)"%frag_name) cmd.set_dihedral("(%s & name N)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name C)"%frag_name, "(%s & name OXT)"%frag_name,180.0+angle) cmd.deprotect(frag_name) # fix the hydrogen position (if any) if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%frag_name)==1: if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%src_sele)==1: cmd.iterate_state(1,"(hydro and bound_to (name N & (%s)))"%src_sele, "stored.list=[x,y,z]") cmd.alter_state(1,"(hydro and bound_to (name N & (%s)))"%frag_name, "(x,y,z)=stored.list") elif cmd.select(tmp_sele1,"(name C & bound_to (%s and elem N))"%src_sele)==1: # position hydro based on location of the carbonyl angle = cmd.get_dihedral("(%s & name C)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name N)"%frag_name, tmp_sele1) cmd.set_dihedral("(%s & name C)"%frag_name, "(%s & name CA)"%frag_name, "(%s & name N)"%frag_name, "(%s & name H)"%frag_name,180.0+angle) cmd.delete(tmp_sele1) # add c-cap (if appropriate) if self.c_cap in [ 'amin', 'nmet' ]: if not cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"% (src_sele,src_sele)): if cmd.count_atoms("name C & (%s)"%(frag_name))==1: if self.c_cap == 'amin': editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nhh') elif self.c_cap == 'nmet': editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nme') if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name): cmd.h_fix("name N & bound_to (name C & (%s))"%frag_name) # trim hydrogens if (self.hyd == 'none'): cmd.remove("("+frag_name+" and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("("+src_sele+") and hydro")==0: cmd.remove("("+frag_name+" and hydro)") # add n-cap (if appropriate) if self.n_cap in [ 'acet' ]: if not cmd.count_atoms("elem C & !(%s) & (bto. (name N & (%s))) & !resn ACE "% (src_sele,src_sele)): if cmd.count_atoms("name N & (%s)"%(frag_name))==1: if self.n_cap == 'acet': editor.attach_amino_acid("name N & (%s)"%(frag_name), 'ace') if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name): cmd.h_fix("name N & (%s)"%frag_name) # trim hydrogens if (self.hyd == 'none'): cmd.remove("("+frag_name+" and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("("+src_sele+") and hydro")==0: cmd.remove("("+frag_name+" and hydro)") cartoon = (cmd.count_atoms("(%s & name CA & rep cartoon)"%src_sele)>0) sticks = (cmd.count_atoms("(%s & name CA & rep sticks)"%src_sele)>0) cmd.delete(obj_name) key = rot_type lib = None if self.dep == 'dep': try: result = cmd.phi_psi("%s"%src_sele) if len(result)==1: (phi,psi) = list(result.values())[0] (phi,psi) = (int(10*round(phi/10)),int(10*(round(psi/10)))) key = (rot_type,phi,psi) if key not in self.dep_library: (phi,psi) = (int(20*round(phi/20)),int(20*(round(psi/20)))) key = (rot_type,phi,psi) if key not in self.dep_library: (phi,psi) = (int(60*round(phi/60)),int(60*(round(psi/60)))) key = (rot_type,phi,psi) lib = self.dep_library.get(key,None) except: pass if lib is None: key = rot_type lib = self.ind_library.get(key,None) if (lib is not None) and self.dep == 'dep': print(' Mutagenesis: no phi/psi, using backbone-independent rotamers.') if lib is not None: state = 1 for a in lib: cmd.create(obj_name,frag_name,1,state) if state == 1: cmd.select(mut_sele,"(byres (%s like %s))"%(obj_name,src_sele)) if rot_type=='PRO': cmd.unbond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele) for b in a.keys(): if b!='FREQ': cmd.set_dihedral("(%s & n;%s)"%(mut_sele,b[0]), "(%s & n;%s)"%(mut_sele,b[1]), "(%s & n;%s)"%(mut_sele,b[2]), "(%s & n;%s)"%(mut_sele,b[3]), a[b],state=state) else: cmd.set_title(obj_name,state,"%1.1f%%"%(a[b]*100)) if rot_type=='PRO': cmd.bond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele) state = state + 1 cmd.delete(frag_name) print(" Mutagenesis: %d rotamers loaded."%len(lib)) if self.bump_check: cmd.delete(bump_name) cmd.create(bump_name, "(((byobj %s) within 6 of (%s and not name N+C+CA+O+H+HA)) and (not (%s)))|(%s)"% (src_sele,mut_sele,src_sele,mut_sele),singletons=1) cmd.color("gray50",bump_name+" and elem C") cmd.set("seq_view",0,bump_name,quiet=1) cmd.hide("everything",bump_name) if ((cmd.select(tmp_sele1, "(name N & (%s in (neighbor %s)))"% (bump_name,src_sele)) == 1) and (cmd.select(tmp_sele2, "(name C & (%s in %s))"% (bump_name,mut_sele)) == 1)): cmd.bond(tmp_sele1,tmp_sele2) if ((cmd.select(tmp_sele1,"(name C & (%s in (neighbor %s)))"% (bump_name,src_sele)) == 1) and (cmd.select(tmp_sele2,"(name N & (%s in %s))"% (bump_name,mut_sele)) == 1)): cmd.bond(tmp_sele1,tmp_sele2) cmd.delete(tmp_sele1) cmd.delete(tmp_sele2) cmd.protect("%s and not (%s in (%s and not name N+C+CA+O+H+HA))"% (bump_name,bump_name,mut_sele)) cmd.sculpt_activate(bump_name) cmd.show("cgo",bump_name) # draw the bumps cmd.set("sculpt_vdw_vis_mode",1,bump_name) state = 1 score_best = 1e6 for a in lib: score = cmd.sculpt_iterate(bump_name, state, 1) self.bump_scores.append(score) if score < score_best: state_best = state score_best = score state = state + 1 cmd.delete(mut_sele) else: cmd.create(obj_name,frag_name,1,1) print(" Mutagenesis: no rotamers found in library.") cmd.set("seq_view",0,obj_name,quiet=1) pymol.util.cbaw(obj_name) cmd.hide("("+obj_name+")") cmd.show(self.rep,obj_name) cmd.show('lines',obj_name) #neighbor always show lines if cartoon: cmd.show("cartoon",obj_name) if sticks: cmd.show("sticks",obj_name) cmd.set('auto_zoom',auto_zoom,quiet=1) cmd.delete(frag_name) cmd.frame(state_best) cmd.unpick() cmd.feedback("pop")
def format_bonds( selection='all', bonds=4, ): ''' DESCRIPTION Formats bonds in aromatic or charged residues EXAMPLE frag PHE format_bonds USAGE format_bonds [ selection [, bonds ]] ARGUMENTS selection: <str> input selection {default: 'all'} bonds: <int> toogles format of bonds 1: single bonds (deactivates valence display) 2: regular double bonds (activates valence display) >=3: delocalized (activates valence display) ''' # Selection try: # group selection with bracketing and select complete residues selection = '(byres (' + str(selection) + '))' # checks functional selection cmd.count_atoms(selection) except: print "invalid selection" return False # PARAMETERS try: bonds = int(bonds) except: pass if (not (bonds in [1, 2])): bonds = 4 if bonds == 1: cmd.set('valence', 0) print "Valence display disabled!" return bonds else: cmd.set('valence', 1) print "Valence display enabled!" # proceed ##### SELECTION BY OBJECT AND CHAIN ##### # variable for the selections # get the names of the proteins in the selection objects = cmd.get_object_list(selection) # include chains # subselect chains names = [] for p in objects: for chain in cmd.get_chains('model ' + p) or ['']: names.append("(model %s and chain '%s')" % (p, chain)) ##### SELECTION LISTS ##### # get TRP stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn TRP+NIW) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) # the integer is to ensure unique keys TRP_tuple = (1,) + tuple(stored.temp) # get PHETYR stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn PHE+TYR+PTR+NIY+PNIY) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) PHETYR_tuple = (2,) + tuple(stored.temp) # get HIS stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn HIS) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) HIS_tuple = (3,) + tuple(stored.temp) # get NITRO stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn NIY+PNIY+NIW) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) NITRO_tuple = (4,) + tuple(stored.temp) # get GLU stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn GLU) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) GLU_tuple = (5,) + tuple(stored.temp) # get ASP stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn ASP) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) ASP_tuple = (6,) + tuple(stored.temp) # get CTERM stored.temp = [] for p in names: cmd.iterate( '(byres (last %s)) and (not (hetatm)) ' 'and (name OXT)' % (p), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) CTERM_tuple = (7,) + tuple(stored.temp) # get ARG stored.temp = [] for p in names: cmd.iterate(( '(%s) and (resn ARG) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p ) ARG_tuple = (8,) + tuple(stored.temp) ##### SELECTION TUPLES DONE ##### ##### ATOM LISTS ##### TRP_bonds_all = [ ['CG', 'CD1'], ['CD1', 'NE1'], ['NE1', 'CE2'], ['CE2', 'CD2'], ['CD2', 'CG'], ['CD2', 'CE3'], ['CE3', 'CZ3'], ['CZ3', 'CH2'], ['CH2', 'CZ2'], ['CZ2', 'CE2'] ] TRP_bonds_double = [ ['CG', 'CD1'], ['CE2', 'CD2'], ['CE3', 'CZ3'], ['CH2', 'CZ2'] ] PHETYR_bonds_all = [ ['CG', 'CD1'], ['CD1', 'CE1'], ['CE1', 'CZ'], ['CZ', 'CE2'], ['CE2', 'CD2'], ['CD2', 'CG'] ] PHETYR_bonds_double = [ ['CG', 'CD1'], ['CE1', 'CZ'], ['CE2', 'CD2'] ] HIS_bonds_all = [ ['CG', 'CD2'], ['CD2', 'NE2'], ['NE2', 'CE1'], ['CE1', 'ND1'], ['ND1', 'CG'], ] HIS_bonds_double = [ ['CG', 'CD2'], ['CE1', 'ND1'] ] NITRO_bonds_all = [ ['NN', 'O1'], ['NN', 'O2'] ] NITRO_bonds_double = [ ['NN', 'O1'] ] GLU_bonds_all = [ ['CD', 'OE1'], ['CD', 'OE2'] ] GLU_bonds_double = [ ['CD', 'OE1'] ] ASP_bonds_all = [ ['CG', 'OD1'], ['CG', 'OD2'] ] ASP_bonds_double = [ ['CG', 'OD1'] ] CTERM_bonds_all = [ ['C', 'O'], ['C', 'OXT'] ] CTERM_bonds_double = [ ['C', 'O'] ] ARG_bonds_all = [ ['CZ', 'NH1'], ['CZ', 'NH2'] ] ARG_bonds_double=[ ['CZ','NH1'] ] ##### FORMATING ##### # dictionary: entries:atoms format_dict = { TRP_tuple: [TRP_bonds_all, TRP_bonds_double], PHETYR_tuple: [PHETYR_bonds_all, PHETYR_bonds_double], HIS_tuple: [HIS_bonds_all, HIS_bonds_double], NITRO_tuple: [NITRO_bonds_all, NITRO_bonds_double], GLU_tuple: [GLU_bonds_all, GLU_bonds_double], ASP_tuple: [ASP_bonds_all, ASP_bonds_double], CTERM_tuple: [CTERM_bonds_all, CTERM_bonds_double], ARG_tuple: [ARG_bonds_all, ARG_bonds_double] } if bonds != 2: lines = 4 print "Formating as delocalized bonds" else: lines = 1 print "Formating as double bonds" # for all tuples (i.e format_dict.keys()) for p in format_dict.keys(): # go through list except ID at pos 1 for q in p[1:]: # format bonds for r in format_dict[p][0]: cmd.unbond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1])) cmd.bond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1]), lines) if lines == 1: # add double bonds for r in format_dict[p][1]: cmd.unbond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1])) cmd.bond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1]), 2) return bonds
def do_library(self): cmd = self.cmd pymol = cmd._pymol if not ( (cmd.count_atoms("(%s) and name n" % src_sele) == 1) and (cmd.count_atoms("(%s) and name c" % src_sele) == 1) and (cmd.count_atoms("(%s) and name o" % src_sele) == 1) ): self.clear() return 1 cmd.feedback("push") cmd.feedback("disable", "selector", "everythin") cmd.feedback("disable", "editor", "actions") self.prompt = ["Loading rotamers..."] pymol.stored.name = "residue" cmd.iterate("first (%s)" % src_sele, 'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi') self.res_text = pymol.stored.name cmd.select("_seeker_hilight", src_sele) auto_zoom = cmd.get_setting_text("auto_zoom") cmd.set("auto_zoom", "0", quiet=1) cmd.frame(0) cmd.delete(frag_name) if self.auto_center: cmd.center(src_sele, animate=-1) self.lib_mode = self.mode if self.lib_mode == "current": pymol.stored.resn = "" cmd.iterate("(%s and n;ca)" % src_sele, "stored.resn=resn") rot_type = _rot_type_xref.get(pymol.stored.resn, pymol.stored.resn) if (self.c_cap != "none") or (self.n_cap != "none") or (self.hyd != "auto"): self.lib_mode = rot_type # force fragment-based load else: cmd.create(frag_name, src_sele, 1, 1) if self.c_cap == "open": cmd.remove("%s and name OXT" % frag_name) if self.lib_mode != "current": rot_type = self.lib_mode frag_type = self.lib_mode if (self.n_cap == "posi") and (frag_type[0:3] != "NT_"): if not (cmd.count_atoms("elem c & !(%s) & (bto. (n;n & (%s))) &! r. ace" % (src_sele, src_sele))): # use N-terminal fragment frag_type = "NT_" + frag_type if (self.c_cap == "nega") and (frag_type[0:3] != "CT_"): if not (cmd.count_atoms("elem n & !(%s) & (bto. (n;c & (%s))) & !r. nme+nhh" % (src_sele, src_sele))): # use C-terminal fragment frag_type = "CT_" + frag_type if rot_type[0:3] in ["NT_", "CT_"]: rot_type = rot_type[3:] rot_type = _rot_type_xref.get(rot_type, rot_type) cmd.fragment(string.lower(frag_type), frag_name) # trim off hydrogens if self.hyd == "none": cmd.remove("(" + frag_name + " and hydro)") elif self.hyd == "auto": if cmd.count_atoms("(" + src_sele + ") and hydro") == 0: cmd.remove("(" + frag_name + " and hydro)") # copy identifying information cmd.iterate("(%s and n;ca)" % src_sele, "stored.chain=chain") cmd.alter("(%s)" % frag_name, "chain=stored.chain") cmd.iterate("(%s and n;ca)" % src_sele, "stored.resi=resi") cmd.alter("(%s)" % frag_name, "resi=stored.resi") cmd.iterate("(%s and n;ca)" % src_sele, "stored.segi=segi") cmd.alter("(%s)" % frag_name, "segi=stored.segi") cmd.iterate("(%s and n;ca)" % src_sele, "stored.ss=ss") cmd.alter("(%s)" % frag_name, "ss=stored.ss") # move the fragment if (cmd.count_atoms("(%s and n;cb)" % frag_name) == 1) and ( cmd.count_atoms("(%s and n;cb)" % src_sele) == 1 ): cmd.pair_fit( "(%s and n;ca)" % frag_name, "(%s and n;ca)" % src_sele, "(%s and n;cb)" % frag_name, "(%s and n;cb)" % src_sele, "(%s and n;c)" % frag_name, "(%s and n;c)" % src_sele, "(%s and n;n)" % frag_name, "(%s and n;n)" % src_sele, ) else: cmd.pair_fit( "(%s and n;ca)" % frag_name, "(%s and n;ca)" % src_sele, "(%s and n;c)" % frag_name, "(%s and n;c)" % src_sele, "(%s and n;n)" % frag_name, "(%s and n;n)" % src_sele, ) # fix the carbonyl position... cmd.iterate_state(1, "(%s and n;o)" % src_sele, "stored.list=[x,y,z]") cmd.alter_state(1, "(%s and n;o)" % frag_name, "(x,y,z)=stored.list") if cmd.count_atoms("(%s and n;oxt)" % src_sele): cmd.iterate_state(1, "(%s and n;oxt)" % src_sele, "stored.list=[x,y,z]") cmd.alter_state(1, "(%s and n;oxt)" % frag_name, "(x,y,z)=stored.list") elif cmd.count_atoms("(%s and n;oxt)" % frag_name): # place OXT if no template exists angle = cmd.get_dihedral( "(%s and n;n)" % frag_name, "(%s and n;ca)" % frag_name, "(%s and n;c)" % frag_name, "(%s and n;o)" % frag_name, ) cmd.protect("(%s and n;o)" % frag_name) cmd.set_dihedral( "(%s and n;n)" % frag_name, "(%s and n;ca)" % frag_name, "(%s and n;c)" % frag_name, "(%s and n;oxt)" % frag_name, 180.0 + angle, ) cmd.deprotect(frag_name) # fix the hydrogen position (if any) if cmd.count_atoms("(elem h and bound_to (n;n and (%s)))" % frag_name) == 1: if cmd.count_atoms("(elem h and bound_to (n;n and (%s)))" % src_sele) == 1: cmd.iterate_state(1, "(elem h and bound_to (n;n and (%s)))" % src_sele, "stored.list=[x,y,z]") cmd.alter_state(1, "(elem h and bound_to (n;n and (%s)))" % frag_name, "(x,y,z)=stored.list") elif cmd.select(tmp_sele1, "(n;c and bound_to (%s and e;n))" % src_sele) == 1: # position hydro based on location of the carbonyl angle = cmd.get_dihedral( "(%s and n;c)" % frag_name, "(%s and n;ca)" % frag_name, "(%s and n;n)" % frag_name, tmp_sele1 ) cmd.set_dihedral( "(%s and n;c)" % frag_name, "(%s and n;ca)" % frag_name, "(%s and n;n)" % frag_name, "(%s and n;h)" % frag_name, 180.0 + angle, ) cmd.delete(tmp_sele1) # add c-cap (if appropriate) if self.c_cap in ["amin", "nmet"]: if not cmd.count_atoms("elem n & !(%s) & (bto. (n;c & (%s))) & !r. nme+nhh" % (src_sele, src_sele)): if cmd.count_atoms("n;c & (%s)" % (frag_name)) == 1: if self.c_cap == "amin": editor.attach_amino_acid("n;c & (%s)" % (frag_name), "nhh") elif self.c_cap == "nmet": editor.attach_amino_acid("n;c & (%s)" % (frag_name), "nme") if cmd.count_atoms("hydro & bound_to (n;n & bound_to (n;c & (%s)))" % frag_name): cmd.h_fix("n;n & bound_to (n;c & (%s))" % frag_name) # trim hydrogens if self.hyd == "none": cmd.remove("(" + frag_name + " and hydro)") elif self.hyd == "auto": if cmd.count_atoms("(" + src_sele + ") and hydro") == 0: cmd.remove("(" + frag_name + " and hydro)") # add n-cap (if appropriate) if self.n_cap in ["acet"]: if not cmd.count_atoms("elem c & !(%s) & (bto. (n;n & (%s))) & !r. ace " % (src_sele, src_sele)): if cmd.count_atoms("n;n & (%s)" % (frag_name)) == 1: if self.n_cap == "acet": editor.attach_amino_acid("n;n & (%s)" % (frag_name), "ace") if cmd.count_atoms("hydro & bound_to (n;n & bound_to (n;c & (%s)))" % frag_name): cmd.h_fix("n;n & (%s)" % frag_name) # trim hydrogens if self.hyd == "none": cmd.remove("(" + frag_name + " and hydro)") elif self.hyd == "auto": if cmd.count_atoms("(" + src_sele + ") and hydro") == 0: cmd.remove("(" + frag_name + " and hydro)") cartoon = cmd.count_atoms("(%s and n;ca and rep cartoon)" % src_sele) > 0 sticks = cmd.count_atoms("(%s and n;ca and rep sticks)" % src_sele) > 0 cmd.delete(obj_name) key = rot_type lib = None if self.dep == "dep": try: result = cmd.phi_psi("%s" % src_sele) if len(result) == 1: (phi, psi) = result[result.keys()[0]] (phi, psi) = (int(10 * round(phi / 10)), int(10 * (round(psi / 10)))) key = (rot_type, phi, psi) if not self.dep_library.has_key(key): (phi, psi) = (int(20 * round(phi / 20)), int(20 * (round(psi / 20)))) key = (rot_type, phi, psi) if not self.dep_library.has_key(key): (phi, psi) = (int(60 * round(phi / 60)), int(60 * (round(psi / 60)))) key = (rot_type, phi, psi) lib = self.dep_library.get(key, None) except: pass if lib == None: key = rot_type lib = self.ind_library.get(key, None) if (lib != None) and self.dep == "dep": print " Mutagenesis: no phi/psi, using backbone-independent rotamers." if lib != None: state = 1 for a in lib: cmd.create(obj_name, frag_name, 1, state) if state == 1: cmd.select(mut_sele, "(byres (%s like %s))" % (obj_name, src_sele)) if rot_type == "PRO": cmd.unbond("(%s & name N)" % mut_sele, "(%s & name CD)" % mut_sele) for b in a.keys(): if b != "FREQ": cmd.set_dihedral( "(%s & n;%s)" % (mut_sele, b[0]), "(%s & n;%s)" % (mut_sele, b[1]), "(%s & n;%s)" % (mut_sele, b[2]), "(%s & n;%s)" % (mut_sele, b[3]), a[b], state=state, ) else: cmd.set_title(obj_name, state, "%1.1f%%" % (a[b] * 100)) if rot_type == "PRO": cmd.bond("(%s & name N)" % mut_sele, "(%s & name CD)" % mut_sele) state = state + 1 cmd.delete(frag_name) print " Mutagenesis: %d rotamers loaded." % len(lib) if self.bump_check: cmd.delete(bump_name) cmd.create( bump_name, "(((byobj %s) within 6 of (%s and not name n+c+ca+o+h+ha)) and (not (%s)))|(%s)" % (src_sele, mut_sele, src_sele, mut_sele), singletons=1, ) cmd.color("gray50", bump_name + " and elem c") cmd.set("seq_view", 0, bump_name, quiet=1) cmd.hide("everything", bump_name) if (cmd.select(tmp_sele1, "(n;N and (%s in (neighbor %s)))" % (bump_name, src_sele)) == 1) and ( cmd.select(tmp_sele2, "(n;C and (%s in %s))" % (bump_name, mut_sele)) == 1 ): cmd.bond(tmp_sele1, tmp_sele2) if (cmd.select(tmp_sele1, "(n;C and (%s in (neighbor %s)))" % (bump_name, src_sele)) == 1) and ( cmd.select(tmp_sele2, "(n;N and (%s in %s))" % (bump_name, mut_sele)) == 1 ): cmd.bond(tmp_sele1, tmp_sele2) cmd.delete(tmp_sele1) cmd.delete(tmp_sele2) cmd.protect("%s and not (%s in (%s and not name n+c+ca+o+h+ha))" % (bump_name, bump_name, mut_sele)) cmd.sculpt_activate(bump_name) cmd.show("cgo", bump_name) # draw the bumps cmd.set("sculpt_vdw_vis_mode", 1, bump_name) state = 1 for a in lib: cmd.sculpt_iterate(bump_name, state=state) state = state + 1 cmd.delete(mut_sele) else: cmd.create(obj_name, frag_name, 1, 1) print " Mutagenesis: no rotamers found in library." cmd.set("seq_view", 0, obj_name, quiet=1) pymol.util.cbaw(obj_name) cmd.hide("(" + obj_name + ")") cmd.show(self.rep, obj_name) cmd.show("lines", obj_name) # neighbor always show lines if cartoon: cmd.show("cartoon", obj_name) if sticks: cmd.show("sticks", obj_name) cmd.set("auto_zoom", auto_zoom, quiet=1) cmd.delete(frag_name) cmd.frame(0) cmd.unpick() cmd.feedback("pop")
def format_bonds( selection='all', bonds=4, ): ''' DESCRIPTION Formats bonds in aromatic or charged residues EXAMPLE frag PHE format_bonds USAGE format_bonds [ selection [, bonds ]] ARGUMENTS selection: <str> input selection {default: 'all'} bonds: <int> toogles format of bonds 1: single bonds (deactivates valence display) 2: regular double bonds (activates valence display) >=3: delocalized (activates valence display) ''' # Selection try: # group selection with bracketing and select complete residues selection = '(byres (' + str(selection) + '))' # checks functional selection cmd.count_atoms(selection) except: print("invalid selection") return False # PARAMETERS try: bonds = int(bonds) except: pass if (not (bonds in [1, 2])): bonds = 4 if bonds == 1: cmd.set('valence', 0) print("Valence display disabled!") return bonds else: cmd.set('valence', 1) print("Valence display enabled!") # proceed ##### SELECTION BY OBJECT AND CHAIN ##### # variable for the selections # get the names of the proteins in the selection objects = cmd.get_object_list(selection) # include chains # subselect chains names = [] for p in objects: for chain in cmd.get_chains('model ' + p) or ['']: names.append("(model %s and chain '%s')" % (p, chain)) ##### SELECTION LISTS ##### # get TRP stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn TRP+NIW) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) # the integer is to ensure unique keys TRP_tuple = (1, ) + tuple(stored.temp) # get PHETYR stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn PHE+TYR+PTR+NIY+PNIY) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) PHETYR_tuple = (2, ) + tuple(stored.temp) # get HIS stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn HIS) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) HIS_tuple = (3, ) + tuple(stored.temp) # get NITRO stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn NIY+PNIY+NIW) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) NITRO_tuple = (4, ) + tuple(stored.temp) # get GLU stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn GLU) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) GLU_tuple = (5, ) + tuple(stored.temp) # get ASP stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn ASP) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) ASP_tuple = (6, ) + tuple(stored.temp) # get CTERM stored.temp = [] for p in names: cmd.iterate( '(byres (last %s)) and (not (hetatm)) ' 'and (name OXT)' % (p), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) CTERM_tuple = (7, ) + tuple(stored.temp) # get ARG stored.temp = [] for p in names: cmd.iterate(('(%s) and (resn ARG) ' 'and (name CA)' % (p)), 'stored.temp.append("(%s and resi "+str(resi)+")")' % p) ARG_tuple = (8, ) + tuple(stored.temp) ##### SELECTION TUPLES DONE ##### ##### ATOM LISTS ##### TRP_bonds_all = [['CG', 'CD1'], ['CD1', 'NE1'], ['NE1', 'CE2'], ['CE2', 'CD2'], ['CD2', 'CG'], ['CD2', 'CE3'], ['CE3', 'CZ3'], ['CZ3', 'CH2'], ['CH2', 'CZ2'], ['CZ2', 'CE2']] TRP_bonds_double = [['CG', 'CD1'], ['CE2', 'CD2'], ['CE3', 'CZ3'], ['CH2', 'CZ2']] PHETYR_bonds_all = [['CG', 'CD1'], ['CD1', 'CE1'], ['CE1', 'CZ'], ['CZ', 'CE2'], ['CE2', 'CD2'], ['CD2', 'CG']] PHETYR_bonds_double = [['CG', 'CD1'], ['CE1', 'CZ'], ['CE2', 'CD2']] HIS_bonds_all = [ ['CG', 'CD2'], ['CD2', 'NE2'], ['NE2', 'CE1'], ['CE1', 'ND1'], ['ND1', 'CG'], ] HIS_bonds_double = [['CG', 'CD2'], ['CE1', 'ND1']] NITRO_bonds_all = [['NN', 'O1'], ['NN', 'O2']] NITRO_bonds_double = [['NN', 'O1']] GLU_bonds_all = [['CD', 'OE1'], ['CD', 'OE2']] GLU_bonds_double = [['CD', 'OE1']] ASP_bonds_all = [['CG', 'OD1'], ['CG', 'OD2']] ASP_bonds_double = [['CG', 'OD1']] CTERM_bonds_all = [['C', 'O'], ['C', 'OXT']] CTERM_bonds_double = [['C', 'O']] ARG_bonds_all = [['CZ', 'NH1'], ['CZ', 'NH2']] ARG_bonds_double = [['CZ', 'NH1']] ##### FORMATING ##### # dictionary: entries:atoms format_dict = { TRP_tuple: [TRP_bonds_all, TRP_bonds_double], PHETYR_tuple: [PHETYR_bonds_all, PHETYR_bonds_double], HIS_tuple: [HIS_bonds_all, HIS_bonds_double], NITRO_tuple: [NITRO_bonds_all, NITRO_bonds_double], GLU_tuple: [GLU_bonds_all, GLU_bonds_double], ASP_tuple: [ASP_bonds_all, ASP_bonds_double], CTERM_tuple: [CTERM_bonds_all, CTERM_bonds_double], ARG_tuple: [ARG_bonds_all, ARG_bonds_double] } if bonds != 2: lines = 4 print("Formating as delocalized bonds") else: lines = 1 print("Formating as double bonds") # for all tuples (i.e format_dict.keys()) for p in list(format_dict.keys()): # go through list except ID at pos 1 for q in p[1:]: # format bonds for r in format_dict[p][0]: cmd.unbond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1])) cmd.bond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1]), lines) if lines == 1: # add double bonds for r in format_dict[p][1]: cmd.unbond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1])) cmd.bond('%s and name %s' % (q, r[0]), '%s and name %s' % (q, r[1]), 2) return bonds