def rmsf2b(selection='all', linearscale=1.0, var='b', quiet=1): ''' DESCRIPTION Determine the root mean square fluctuation (RMSF) per atom for a multi-state object and assign b-factor ARGUMENTS selection = string: atom selection {default: name CA} linearscale = float: if linearscale <= 0, then use real b-factor equation, else use b=(rmsf*linearscale) {default: 1.0} SEE ALSO spheroid, rmsf_states.py from Robert Campbell ''' _assert_package_import() from . import querying from numpy import asfarray, sqrt, pi linearscale = float(linearscale) coords = asfarray(querying.get_ensemble_coords(selection)) n_states, n_atoms, _ = coords.shape if n_atoms == 0 or n_states < 2: print(' Error: not enough atoms or states') raise CmdException u_sq = coords.var(0).sum(1) # var over states, sum over x,y,z b_array = sqrt(u_sq) * linearscale if linearscale > 0.0 \ else 8 * pi**2 * u_sq cmd.alter(selection, var + ' = next(b_iter)', space={'b_iter': iter(b_array), 'next': next}) if not int(quiet): print(' Average RMSF: %.2f' % (sqrt(u_sq).mean())) return b_array
def nicecolor(method, selection='all'): """ DESCRIPTION color a selection with unique colors based on atom properties exposed by iterate USAGE nicecolor method [, selection] ARGUMENTS method = property that will be used as a method for coloring (e.g.: "resi") selection = selection to act upon """ stored.tmp_dict = {} stored.r_choice = random.choice cmd.iterate( selection, f'stored.tmp_dict[{method}] = stored.r_choice(stored.nice_colors)') cmd.alter(selection, f'color = stored.tmp_dict[{method}]') cmd.sync() del stored.tmp_dict cmd.recolor() cmd.sync()
def plot(self, outfile): ctrl_id, case_id, snp_df_sub = self.score_on_var() df = pd.merge(snp_df_sub, self.snps2aa, on='id') #pymol.finish_launching() cmd.reinitialize() cmd.fetch(self.pdb) cmd.alter(self.pdb, 'b = 0.5') cmd.show_as('cartoon', self.pdb) cmd.color('white', self.pdb) for i, row in df.iterrows(): resi = row['structure_position'] chain = row['chain'] pheno = row['es'] selec = 'snp%s' % i selec_atom = 'snp_atom%s' % i cmd.select(selec, 'name ca and resi %s and chain %s' % (resi, chain)) cmd.create(selec_atom, selec) cmd.set("sphere_scale", 0.8) cmd.show('sphere', selec_atom) cmd.alter(selec_atom, 'b=%s' % pheno) cmd.spectrum("b", "blue_white_red", selec_atom, maximum=1.0, minimum=0.0) cmd.bg_color("white") cmd.zoom() cmd.orient() cmd.save('%s.pse' % outfile) cmd.png('%s.png' % outfile, width=2400, height=2400, dpi=300, ray=1)
def hs_resize(meta_file, selection): if not is_sele(selection): raise RuntimeError( "Selection \"{}\" does not exists.".format(selection)) # Find free sele name temp_sele = _random_string() while is_sele(temp_sele): temp_sele = _random_string() states = cmd.count_states(selection=selection) for state in range(1, states + 1): stored.info = [] cmd.iterate_state(state, selection, "stored.info.append((ID, partial_charge))") for id_, partial_charge in stored.info: size = log(partial_charge / ref + 1) print(ref) print(size) cmd.select(temp_sele, "{} and id {}".format(selection, id_), state=state) cmd.set("sphere_scale", value=size, selection=temp_sele) cmd.alter(temp_sele, "b={}".format(partial_charge)) cmd.delete(temp_sele)
def aver(settings): """ average pdb command :param settings: """ cmd.set('orthoscopic') if settings.config.get('all_states', 0): cmd.set('all_states') LOG.info("Load structure file %s" % settings.args.get('pdb')) try: cmd.load(settings.args.get('pdb')) except CmdException: LOG.error("Can't load %s", settings.args.get('pdb')) mypdb = os.path.splitext(os.path.basename(settings.args.get('pdb')))[0] cmd.hide('everything', mypdb) cmd.show('ribbon', mypdb) cmd.show('spheres', '%s and name CA' % mypdb) cmd.alter(mypdb, 'vdw=%.2f' % settings.config.get('vdwspheres_radius')) cmd.rebuild(mypdb, 'spheres') # Fit to the first state by default (which is the best one according to # aria order) objfit = avg_states(mypdb, object_sel=settings.args.get('sel'), first=settings.config.get('first'), last=settings.config.get('last'), newobj=settings.config.get('newobj'), fitverdict=settings.config.get('fit'), verb=settings.config.get('verb'), pairs=settings.config.get('pairs'), writefiles=settings.config.get('writefiles')) cmd.cartoon('putty', objfit) cmd.show('cartoon', objfit) cmd.spectrum('b', 'blue_white_red', objfit)
def renumber_residues(sel="polymer", start=1): """Renumber residues. Selection should be a single chain. Run from Pymol. See also this module for renumbering based on connectivity: https://pymolwiki.org/index.php/Renumber """ class gen_resi_cl: def __init__(self, start): self.prev_new_resi = start self.prev_old_resi = None def __call__(self, cur_old_resi): if self.prev_old_resi is None: ret = self.prev_new_resi else: if self.prev_old_resi != cur_old_resi: ret = self.prev_new_resi + 1 else: ret = self.prev_new_resi self.prev_old_resi = cur_old_resi self.prev_new_resi = ret print(ret, cur_old_resi) return ret space = dict(gen_resi=gen_resi_cl(start=start)) cmd.alter(sel, "resi=gen_resi(resi)", space=space) cmd.rebuild() cmd.sort()
def drab(nlim=-2.0, plim=2.0): #zero the indexes #zero_residues("all", 1, 1) #Read the values in fileName = cmd.get_names()[0] print fileName fileName = fileName + ".dat" cmd.alter("all", "b=0.0") #file = open(fileName, 'r') #table = [row.strip().split('\t') for row in file] bVals = [] #print table for line in file(fileName): line = line.strip().split() if (line[0][0] != "#"): selection = "resi %s" % line[0] #Normalize the values bval = (float(line[1]) - nlim) / (plim - nlim) #print bval cmd.alter(selection, "b=%f" % bval) print(selection, "b=%f" % bval) bVals.append([selection, bval]) cmd.hide("all") cmd.show("cartoon") cmd.spectrum("b", "blue_white_red", "all", "0.0", "1.0", "1") cmd.ramp_new("rawFac_ramp", cmd.get_names()[0], [nlim, plim], color="[blue, white, red ]") cmd.recolor()
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 useOccRadii(sel="all"): for a in cmd.get_model(sel).atom: q = a.q if q >= 3: print "shrik radius" q <- 0.1 cmd.alter("%s and resi %s and name %s"%(sel,a.resi,a.name),"vdw=%f"%(q))
def alphatoall(selection='polymer', properties='b', operator='byca', quiet=1): ''' DESCRIPTION Expand any given property of the CA atoms to all atoms in the residue Enhanced version of http://pymolwiki.org/index.php/AlphaToAll ARGUMENTS selection = string: atom selection {default: polymer} properties = string: space separated list of atom properties {default: b} ''' properties = '(' + ','.join(properties.split()) + ')' space = {'props': dict()} cmd.iterate('%s (%s)' % (operator, selection), 'props[model,segi,chain,resi] = ' + properties, space=space) cmd.alter(selection, properties + ' = props.get((model,segi,chain,resi), ' + properties + ')', space=space) if not int(quiet): print(' Modified %d residues' % (len(space['props'])))
def loadBfacts (mol,startaa=1,source="/Users/student/Box Sync/PUBS/Pymol-practice.txt", visual="Y"): """ Replaces B-factors with a list of values contained in a plain txt file usage: loadBfacts mol, [startaa, [source, [visual]]] mol = any object selection (within one single object though) startaa = number of first amino acid in 'new B-factors' file (default=1) source = name of the file containing new B-factor values (default=newBfactors.txt) visual = redraws structure as cartoon_putty and displays bar with min/max values (default=Y) example: loadBfacts 1LVM and chain A """ obj=cmd.get_object_list(mol)[0] cmd.alter(mol,"b=-1.0") inFile = open(source, 'r') counter=int(startaa) bfacts=[] for line in inFile.readlines(): bfact=float(line) bfacts.append(bfact) cmd.alter("%s and resi %s and n. CA"%(mol,counter), "b=%s"%bfact) counter=counter+1 if visual=="Y": cmd.show_as("cartoon",mol) cmd.cartoon("putty", mol) cmd.set("cartoon_putty_scale_min", min(bfacts),obj) cmd.set("cartoon_putty_scale_max", max(bfacts),obj) cmd.set("cartoon_putty_transform", 0,obj) cmd.set("cartoon_putty_radius", 0.2,obj) cmd.spectrum("b","rainbow", "%s and n. CA " %mol) cmd.ramp_new("count", obj, [min(bfacts), max(bfacts)], "rainbow") cmd.recolor()
def sequential_residues(sel1, offset=1): """ PURPOSE: renumbers the selected residues sequentially, regardless of gaps USAGE: sequential_residues protName # first residue is 1 USAGE: sequential_residues protName, 5 # first residue is 5 EXAMPLE: sequential_residues * """ offset = int(offset) # A counter from offset up stored.offset = int(offset) - 1 stored.curr_res = None cmd.alter( sel1, """ if stored.curr_res != int(resi): stored.offset=stored.offset + 1 stored.curr_res=int(resi) resi=stored.offset else: resi=stored.offset """, ) cmd.sort()
def color_protein(protein, df): #df["importance"] = np.abs(df["importance"].values) #df["importance"] = np.log(df["importance"].values) #df["importance"] = df["importance"].values/np.max(df["importance"].values) min_imp = min(df["importance"].values) max_imp = max(df["importance"].values) print(min_imp) print(max_imp) cmd.spectrum("b", "blue red", selection=protein, minimum=min_imp, maximum=max_imp) for index in df.index: print(df.loc[index]) resid = int(df.loc[index]["resid"]) net_importance = df.loc[index]["importance"] cmd.alter("resid %d & %s" % (resid, protein), "b=%f" % (net_importance)) cmd.show("ribbon", "resi %d" % resid) if net_importance > np.percentile(df["importance"].values, 95): cmd.show("sticks", "resi %d" % resid) #if "2" in protein: # cmd.util.cbac("resi %d & sidechain & %s" % (resid, protein)) #else: # cmd.util.cbag("resi %d & sidechain & %s" % (resid, protein)) print(resid) print(net_importance)
def useRosettaRadii(): cmd.alter("element C", "vdw=2.00") cmd.alter("element N", "vdw=1.75") cmd.alter("element O", "vdw=1.55") cmd.alter("element H", "vdw=1.00") cmd.alter("element P", "vdw=1.90") cmd.set("sphere_scale", 1.0)
def loadFitnessFactors (mol,startaa=1,source="/Users/student/Box Sync/PUBS/Pymol-practice.txt", visual="Y"): # adapted from http://www.pymolwiki.org/index.php/Load_new_B-factors """ Replaces B-factors with a list of fitness factor values contained in a plain txt file usage: loadFitnessFactors mol, [startaa, [source, [visual]]] mol = any object selection (within one single object though) startaa = number of first amino acid in 'new Fitness-factors' file (default=1) source = name of the file containing new Fitness-factor values (default=newFitnessFactors.txt) visual = redraws structure as cartoon_putty and displays bar with min/max values (default=Y) example: loadFitnessFactors 1LVM and chain A """ obj=cmd.get_object_list(mol)[0] cmd.alter(mol,"b=-1.0") inFile = open(source, 'r') counter=int(startaa) fitnessFacts=[] for line in inFile.readlines(): fitnessFact=float(line) fitnessFacts.append(fitnessFact) cmd.alter("%s and resi %s and n. CA"%(mol,counter), "b=%s"%fitnessFact) counter=counter+1 if visual=="Y": cmd.show_as("cartoon",mol) cmd.cartoon("putty", mol) # cmd.set("cartoon_putty_scale_min", min(fitnessFacts),obj) # cmd.set("cartoon_putty_scale_max", max(fitnessFacts),obj) cmd.set("cartoon_putty_transform", 0,obj) cmd.set("cartoon_putty_radius", 0.2,obj) cmd.spectrum("b","red_white_blue", "%s and n. CA " %mol) cmd.ramp_new("count", obj, [min(fitnessFacts), (min(fitnessFacts)+max(fitnessFacts))/2, max(fitnessFacts)], color = ["blue", "white", "red"]) cmd.recolor()
def zero_residues(sel1, offset=0, chains=0): """ """ offset = int(offset) # variable to store the offset stored.first = None # get the names of the proteins in the selection names = [ '(model %s and (%s))' % (p, sel1) for p in cmd.get_object_list('(' + sel1 + ')') ] if int(chains): names = [ '(%s and chain %s)' % (p, chain) for p in names for chain in cmd.get_chains(p) ] # for each name shown for p in names: # get this offset ok = cmd.iterate("first %s and polymer and n. CA" % p, "stored.first=resv") # don't waste time if we don't have to if not ok or stored.first == offset: continue # reassign the residue numbers cmd.alter("%s" % p, "resi=str(int(resi)-%s)" % str(int(stored.first) - offset)) # update pymol cmd.rebuild()
def corexHDXRateUpdateB(obj, infoFile, exchangeRateFile): """Sets the B-factor column to the HDX rate. infoFile is used to establish the mapping between pdb and corex numbers (*.info). exchangeRateFile gives the HDX rates (*.Exchange_Rates). """ hdx = CorexExchangeRates(exchangeRateFile) info = CorexAtomInfo(infoFile) if info is None: print "Error parsing %s" % infoFile return if hdx is None: print "Error parsing %s" % exchangeRateFile return assignPDBNums( [atom.res for atom in info.getAtoms() if not atom.isHet], hdx.getResidues() ) cmd.alter(obj, "b = -10") for res in hdx.getResidues(): if res.pdbNum is not None and res.exchangeRate is not None: sel = "%s and i. %s and chain %s" % ( obj, res.pdbNum, res.chain) cmd.alter( sel, "b = %f" % res.exchangeRate) cmd.sort(obj)
def corexProtectionFactorUpdateB(obj, infoFile, pfFile): """Sets the B-factor column to the protection factors. infoFile is used to establish the mapping between pdb and corex numbers (*.info). pfFile gives the protection factors (*.Protection_Factors). """ pf = CorexProtectionFactors(pfFile) info = CorexAtomInfo(infoFile) if info is None: print "Error parsing %s" % infoFile return if pf is None: print "Error parsing %s" % exchangeRateFile return assignPDBNums( [atom.res for atom in info.getAtoms() if not atom.isHet], pf.getResidues() ) cmd.alter(obj, "b = -10") for res in pf.getResidues(): if res.pdbNum is not None and res.modifiedProtectionFactor is not None: sel = "%s and i. %s and chain %s" % ( obj, res.pdbNum, res.chain) cmd.alter( sel, "b = %f" % res.modifiedProtectionFactor) cmd.sort(obj)
def test_msms_surface(): eps = 1e-3 cmd.reinitialize() cmd.fragment('ala', 'm1') # default psico.msms.msms_surface(name='surf1') extent = cmd.get_extent('surf1') assert extent[0] == approx([-2.705, -3.208, -2.413], rel=eps) assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps) # global solvent_radius cmd.set('solvent_radius', 3.5) psico.msms.msms_surface(name='surf2') extent = cmd.get_extent('surf2') assert extent[0] == approx([-2.705, -3.169, -2.436], rel=eps) assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps) # object-level solvent_radius cmd.set('solvent_radius', 2.8, 'm1') psico.msms.msms_surface(name='surf3') extent = cmd.get_extent('surf3') assert extent[0] == approx([-2.705, -3.161, -2.427], rel=eps) assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps) # modified atom radii cmd.alter('m1', 'vdw = 3.0') psico.msms.msms_surface(name='surf4') extent = cmd.get_extent('surf4') assert extent[0] == approx([-4.605, -5.162, -4.418], rel=eps) assert extent[1] == approx([5.030, 4.861, 4.681], rel=eps)
def corexDiffSAUpdateB(obj, corex1, corex2): """Sets the B-factor column to the difference in surface areas between files corex1-corex2 """ corex1 = CorexAtomInfo(corex1) if corex1 is None: print "Error parsing %s" % corex1 return corex2 = CorexAtomInfo(corex2) if corex2 is None: print "Error parsing %s" % corex2 return atoms1 = corex1.getAtoms() atoms2 = corex2.getAtoms() if len(atoms1) != len(atoms2): print "Error: Corex files must have identical atoms" #TODO line up atoms1 and atoms2 somehow for i in xrange(len(atoms1)): sel = "%s and n. %s and i. %s and chain %s" % ( obj, atoms1[i].name, atoms1[i].res.pdbNum, atoms1[i].res.chain) cmd.alter( sel, "b = %f" % (atoms1[i].sa-atoms2[i].sa)) print "b = %f" % (atoms1[i].sa-atoms2[i].sa) cmd.sort(obj)
def lsupdateview(self, lig, zone, min, max, prev, index, hlig, label): cmd.hide("all") x = cmd.get_names("all") cmd.label( "( " + x[index] + " and (r. " + lig + " a. " + prev + ") ) and (not (" + x[index] + " and (r. SWT or r. BWT or r. SWP))) " + " and name CA", "\" \"") cmd.show("cartoon", "bo. " + x[index]) cmd.show("sticks", x[index] + " and r. " + lig) cmd.color("white", x[index] + " and pol.") fp = open(tempfile.gettempdir() + "/temp.txt", "r") stored.bfact = [] for line in fp: stored.bfact.append(line) fp.close() cmd.alter(x[index], "b=stored.bfact.pop(0)") cmd.spectrum("b", "blue_white_red", x[index], minimum=min, maximum=max) cmd.ramp_new("ramp_obj", x[index], range=[min, 0, max], color="[blue, white, red ]") cmd.util.cbaw(x[index] + " and r. " + lig) cmd.show( "licorice", "( " + x[index] + " and (r. " + lig + " a. " + zone + ") ) and (not (" + x[index] + " and (r. SWT or r. BWT or r. SWP))) ") cmd.hide("licorice", x[index] + " and r. " + hlig) self.togglelabells(label, index, lig, zone, hlig)
def wsvisualizer(self, index, lig, zone, min, max, label): cmd.hide("all") x = cmd.get_names("all") cmd.show("cartoon", "bo. " + x[index]) cmd.show("sticks", x[index] + " and r. " + lig) cmd.color("white", x[index] + " and pol.") fp = open(tempfile.gettempdir() + "/temp.txt", "r") #tt=0 stored.bfact = [] for line in fp: stored.bfact.append(line) #print(stored.bfact[tt]+"\t"+line+"\t"+str(tt)) #tt=tt+1 #print(tt) fp.close() cmd.alter(x[index], "b=stored.bfact.pop(0)") cmd.spectrum("b", "blue_white_red", x[index], minimum=min, maximum=max) cmd.ramp_new("ramp_obj", x[index], range=[min, 0, max], color="[blue, white, red ]") cmd.util.cbaw(x[index] + " and r. " + lig) cmd.show( "licorice", "( " + x[index] + " and (r. " + lig + " a. " + zone + ") ) and (not (" + x[index] + " and (r. SWT or r. BWT or r. SWP))) ") self.togglelabelws(label, index, lig, zone)
def testCifMissing(self): N = 7 cmd.fragment('gly', 'm1') cmd.alter('all', '(chain, segi, resv, alt) = ("?", ".", 5, "")') s = cmd.get_str('cif') self.assertTrue("'?'" in s or '"?"' in s) # chain self.assertTrue("'.'" in s or '"."' in s) # segi self.assertTrue(' ? ' in s) # e.g. pdbx_PDB_ins_code self.assertTrue(' . ' in s) # e.g. label_alt_id cmd.delete('*') cmd.set('cif_keepinmemory') cmd.load(s, 'm2', format='cifstr') self.assertEqual(['?'], cmd.get_chains()) self.assertEqual(cmd.count_atoms('segi .'), N) self.assertEqual(cmd.count_atoms('alt ""'), N) # no alt self.assertEqual(cmd.count_atoms('resi 5'), N) # no ins_code from pymol.querying import cif_get_array self.assertEqual(cif_get_array("m2", "_atom_site.type_symbol"), list('NCCOHHH')) self.assertEqual(cif_get_array("m2", "_atom_site.id", "i"), list(range(1, N + 1))) self.assertEqual(cif_get_array("m2", "_atom_site.auth_asym_id"), ['?'] * N) self.assertEqual(cif_get_array("m2", "_atom_site.label_asym_id"), ['.'] * N) self.assertEqual(cif_get_array("m2", "_atom_site.pdbx_pdb_ins_code"), [None] * N) self.assertEqual(cif_get_array("m2", "_atom_site.label_alt_id"), [None] * N)
def RefreshDisplay(self): try: # Display the atoms spheres cmd.show('spheres', self.LigDisplay) cmd.refresh() cmd.alter(self.LigDisplay, 'vdw=0.25') cmd.rebuild(self.LigDisplay) cmd.refresh() util.cbag(self.LigDisplay) cmd.refresh() if self.AnchorAtom != -1: AtomSel = self.LigDisplay + ' & id ' + str(self.AnchorAtom) cmd.color('white', AtomSel) cmd.refresh() cmd.alter(AtomSel, 'vdw=0.30') cmd.rebuild(AtomSel) cmd.refresh() except: self.ErrorCode = 1 return self.ErrorCode
def useTempRadii(sel="all"): for a in cmd.get_model(sel).atom: bfac = a.b if bfac >= 3: print "shrik radius" bfac <- 0.1 cmd.alter("%s and resi %s and name %s"%(sel,a.resi,a.name),"vdw=%f"%(bfac))
def highlightDsspSecStruct(pdbFile, dsspBinaryPath): (dsspData, dssp2pdbResnum) = getDsspSecStructHash(runDssp(pdbFile, dsspBinaryPath)) cmd.hide("everything") cmd.select("a", "all") cmd.alter("a", "ss=\'L\'") cmd.show("cartoon", "a") cmd.color("deepblue", "a") for chain in dsspData.keys(): for pdbResNum in dsspData[chain].keys(): print "Reading chain:" + chain + ", residue:" + pdbResNum + ", secstr:" + dsspData[ chain][pdbResNum]["SEC_STRUCT"] if dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'E': highlightResidue(chain, pdbResNum, "cartoon", "grey", 'S') elif dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'B': highlightResidue(chain, pdbResNum, "cartoon", "grey90", 'S') elif dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'H': highlightResidue(chain, pdbResNum, "cartoon", "tv_red", 'H') elif dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'G': highlightResidue(chain, pdbResNum, "cartoon", "magenta", 'H') elif dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'I': highlightResidue(chain, pdbResNum, "cartoon", "pink", 'H') elif dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'T': highlightResidue(chain, pdbResNum, "cartoon", "tv_green", 'L') elif dsspData[chain][pdbResNum]["SEC_STRUCT"] == 'S': highlightResidue(chain, pdbResNum, "cartoon", "limon", 'L') else: highlightResidue(chain, pdbResNum, "cartoon", "forest", 'L') dsspData.clear()
def DisplayLigand(self): try: cmd.set("auto_zoom", 0) cmd.load(self.RefLigand, self.LigDisplay, state=self.State) cmd.refresh() # Display the atoms spheres cmd.show('spheres', self.LigDisplay) cmd.refresh() cmd.alter(self.LigDisplay,'vdw=0.25') cmd.rebuild(self.LigDisplay) cmd.refresh() util.cbag(self.LigDisplay) cmd.refresh() cmd.translate(self.Translation,self.LigDisplay) cmd.refresh() cmd.zoom(self.LigDisplay) cmd.refresh() except: self.ErrorCode = 1 cmd.set("auto_zoom", self.auto_zoom) return self.ErrorCode
def updateSS(self): if self.ss_asgn_prog is None: err_msg = 'Run DSSP or Stride to assign secondary structures first!' print 'ERROR: %s' % (err_msg,) tkMessageBox.showinfo(title='ERROR', message=err_msg) else: print 'Update secondary structures for %s' % (self.pymol_sel.get()), print 'using secondary structure assignment by %s' % (self.ss_asgn_prog,) print 'SSE mapping: (H,G,I) ==> H; (E,B,b) ==> S; (T,S,-,C) ==> L' if self.ss_asgn_prog == 'DSSP': SSE_list = self.DSSP_SSE_list elif self.ss_asgn_prog == 'Stride': SSE_list = self.STRIDE_SSE_list for sse in SSE_list: for sel_obj in self.sel_obj_list: if self.SSE_sel_dict[sel_obj][sse] is not None: cmd.alter(self.SSE_sel_dict[sel_obj][sse], 'ss=\'%s\''% (self.SSE_map[sse],)) print 'alter %s, ss=%s' % (self.SSE_sel_dict[sel_obj][sse], self.SSE_map[sse]) else: print 'No residue with SSE %s to update ss.' % (sse,) # show cartoon for the input selection, and rebuild cmd.show('cartoon',self.pymol_sel.get()) cmd.rebuild(self.pymol_sel.get()) return
def order_atoms_in_peptide(rtpfile, selection='all'): """ DESCRIPTION Order the atoms in the peptide according to the Gromacs .rtp database USAGE order_atoms_in_peptide rtpfile [, selection] ARGUMENTS rtpfile: either a .rtp file (Gromacs residue topology database) or a Gromacs forcefield directory selection: defaults to 'all' """ residuetypes = list(iterate_residues(rtpfile)) residues = {(a.resi_number, a.resn) for a in cmd.get_model(selection).atom} i = 0 for resi, resn in sorted(residues, key=lambda x: x[0]): resn, atomnames, bondtypes = [r for r in residuetypes if r[0] == resn][0] for a in atomnames: print(i, a) cmd.alter( '({}) and (resi {}) and (resn {}) and (name {})'.format( selection, resi, resn, a), 'ID={}'.format(i)) cmd.alter( '({}) and (resi {}) and (resn {}) and (name {})'.format( selection, resi, resn, a), 'rank={}'.format(i)) i += 1
def ss(mol, startaa=1, visual="Y"): """ Replaces B-factors with TALOS predicted secondary structure elements mol = any object selection (within one single object though) startaa = number of first amino acid in 'new B-factors' file (default=1) visual = redraws structure as cartoon_putty and displays bar with min/max values (default=Y) example: ss 1LVM, startaa=4 """ source = 'predSS.tab' ss_dict = {'L': 0, 'H': 2, 'E': 1, 'X': 0} ss_only = [] with open(source) as ss_file: for lines in ss_file: searcher = re.search('^\d+', lines.strip()) if searcher != None: if int(lines.strip().split()[0]) < int(startaa): continue ss_only.append(ss_dict[lines.strip().split()[8]]) obj = cmd.get_object_list(mol)[0] cmd.alter(mol, "b=-1.0") counter = int(startaa) bfacts = [] for line in ss_only: bfact = float(line) bfacts.append(bfact) cmd.alter("%s and resi %s and n. CA" % (mol, counter), "b=%s" % bfact) counter = counter + 1 if visual == "Y": cmd.cartoon("automatic", mol) cmd.spectrum("b", "grey blue red", "%s and n. CA " % mol) cmd.recolor()
def updateSS(self): if self.ss_asgn_prog is None: err_msg = 'Run DSSP or Stride to assign secondary structures first!' print 'ERROR: %s' % (err_msg, ) tkMessageBox.showinfo(title='ERROR', message=err_msg) else: print 'Update secondary structures for %s' % ( self.pymol_sel.get()), print 'using secondary structure assignment by %s' % ( self.ss_asgn_prog, ) print 'SSE mapping: (H,G,I) ==> H; (E,B,b) ==> S; (T,S,-,C) ==> L' if self.ss_asgn_prog == 'DSSP': SSE_list = self.DSSP_SSE_list elif self.ss_asgn_prog == 'Stride': SSE_list = self.STRIDE_SSE_list for sse in SSE_list: for sel_obj in self.sel_obj_list: if self.SSE_sel_dict[sel_obj][sse] is not None: cmd.alter(self.SSE_sel_dict[sel_obj][sse], 'ss=\'%s\'' % (self.SSE_map[sse], )) print 'alter %s, ss=%s' % ( self.SSE_sel_dict[sel_obj][sse], self.SSE_map[sse]) else: print 'No residue with SSE %s to update ss.' % (sse, ) # show cartoon for the input selection, and rebuild cmd.show('cartoon', self.pymol_sel.get()) cmd.rebuild(self.pymol_sel.get()) return
def update_identifiers(target, source, identifiers='segi chain resi', match='align', quiet=1): ''' DESCRIPTION Transfers segi, chain, and resi identifiers from one selection to another. This works by mapping old to new identifiers and alters also not aligned atoms (works if any other atom from the same residue got aligned). ''' from .fitting import matchmaker tmatched, smatched, tmp_names = matchmaker(target, source, match) key = '(' + ','.join(identifiers.split()) + ',)' tkeys, skeys = [], [] cmd.iterate(tmatched, 'tkeys.append(%s)' % (key), space=locals()) cmd.iterate(smatched, 'skeys.append(%s)' % (key), space=locals()) t2s = dict(zip(tkeys, skeys)) cmd.alter(target, '%s = t2s.get(%s, %s)' % (key, key, key), space=locals()) for name in tmp_names: cmd.delete(name)
def test_wildcard_sets_ranges(self): for i in range(10): cmd.pseudoatom('m%d' % i, chain=chr(65 + i)) cmd.alter('m5', 'chain = "AB"') cmd.alter('m6', 'chain = "BA"') cmd.alter('m7', 'chain = "CC"') cmd.alter('m8', 'chain = "ZA"') cmd.alter('m9', 'chain = "ABA"') # A patterns self.assertEqual(1, cmd.count_atoms('chain A')) self.assertEqual(3, cmd.count_atoms('chain A*')) self.assertEqual(4, cmd.count_atoms('chain *A')) self.assertEqual(5, cmd.count_atoms('chain *A*')) self.assertEqual(1, cmd.count_atoms('chain A*A')) # B patterns self.assertEqual(2, cmd.count_atoms('chain B*')) self.assertEqual(2, cmd.count_atoms('chain *B')) self.assertEqual(4, cmd.count_atoms('chain *B*')) # X patterns (no matches) self.assertEqual(0, cmd.count_atoms('chain X*')) self.assertEqual(0, cmd.count_atoms('chain *X')) self.assertEqual(0, cmd.count_atoms('chain *X*')) # list with wildcards self.assertEqual(5, cmd.count_atoms('chain B*+A*')) self.assertEqual(3, cmd.count_atoms('chain B*+A*A')) self.assertEqual(3, cmd.count_atoms('chain B*+A*A+*X')) # lexicographical alpha ranges, A:C, will match AB (A <= AB <= C) but not CC (C < CC) # no wildcards in alpha ranges possible self.assertEqual(6, cmd.count_atoms('chain A:C')) self.assertEqual(6, cmd.count_atoms('chain A:CA')) self.assertEqual(7, cmd.count_atoms('chain A:CX')) # include CC self.assertEqual(6, cmd.count_atoms('chain A:C+Z')) self.assertEqual(7, cmd.count_atoms('chain A:C+Z*'))
def loadBfacts(mol, startaa=1, source="newBfactors.txt", visual="Y"): """ Replaces B-factors with a list of values contained in a plain txt file usage: loadBfacts mol, [startaa, [source, [visual]]] mol = any object selection (within one single object though) startaa = number of first amino acid in 'new B-factors' file (default=1) source = name of the file containing new B-factor values (default=newBfactors.txt) visual = redraws structure as cartoon_putty and displays bar with min/max values (default=Y) example: loadBfacts 1LVM and chain A """ obj = cmd.get_object_list(mol)[0] cmd.alter(mol, "b=-1.0") inFile = open(source, 'r') counter = int(startaa) bfacts = [] for line in inFile.readlines(): bfact = float(line) bfacts.append(bfact) cmd.alter("%s and resi %s and n. CA" % (mol, counter), "b=%s" % bfact) counter = counter + 1 if visual == "Y": cmd.show_as("cartoon", mol) cmd.cartoon("putty", mol) cmd.set("cartoon_putty_scale_min", min(bfacts), obj) cmd.set("cartoon_putty_scale_max", max(bfacts), obj) cmd.set("cartoon_putty_transform", 0, obj) cmd.set("cartoon_putty_radius", 0.2, obj) cmd.spectrum("b", "rainbow", "%s and n. CA " % mol) cmd.ramp_new("count", obj, [min(bfacts), max(bfacts)], "rainbow") cmd.recolor()
def testExportStyle(self): cmd.fab('ACDEF', 'm1') cmd.hide() cmd.show('cartoon', 'resi 1-3') cmd.show('lines', 'resn CYS') cmd.show('sticks', 'resn ASP+PHE') cmd.show('spheres', 'resn GLU') cmd.set('stick_ball', 1, 'resn PHE') cmd.set('stick_ball_ratio', 1.5, 'm1') testlabel = 'Hello "World"' cmd.label('name SG', repr(testlabel)) with testing.mktemp('.mae') as filename: cmd.save(filename) cmd.delete('*') cmd.load(filename, 'm2') g_labels = [] cmd.iterate('name SG', 'g_labels.append(label)', space=locals()) cmd.alter('*', 'b = 1 if s.stick_ball else 0') self._assertCountEqual('rep cartoon & guide', 'resi 1-3 & guide') self._assertCountEqual('rep lines', 'resn CYS', delta=1) self._assertCountEqual('rep sticks', 'resn ASP+PHE') self._assertCountEqual('rep spheres', 'resn GLU') self._assertCountEqual('b > 0.5', 'resn PHE') self.assertTrue(cmd.get_setting_float('stick_ball_ratio', 'm2') > 1.1) self.assertEqual(g_labels[0], testlabel)
def output_PNG(this_PDB_file, OUTPUT_FOLDER_PNG, OUTPUT_FOLDER_SESSION): # show complex cmd.hide("all") cmd.bg_color("white") cmd.show("cartoon", "this_complex") # show protein A cmd.set_color("A_interface_color", [167, 244, 66]) # lightgreen cmd.set_color("A_C_term_color", [252, 245, 146]) # pale yellow cmd.color("yellow", "chain A") cmd.color("A_interface_color", "A_interface") cmd.alter("A_center_pseudoatom", "vdw=2") cmd.show("sphere", "A_center_pseudoatom") cmd.color("green", "A_center_pseudoatom") cmd.show("sphere", "A_N_term") cmd.color("yellow", "A_N_term") cmd.show("sphere", "A_C_term") cmd.color("A_C_term_color", "A_C_term") # show protein B cmd.set_color("B_interface_color", [80, 181, 244]) # medium blue cmd.set_color("B_C_term_color", [179, 229, 229]) # pale cyan cmd.color("cyan", "chain B") cmd.color("B_interface_color", "B_interface") cmd.alter("B_center_pseudoatom", "vdw=2") cmd.show("sphere", "B_center_pseudoatom") cmd.color("blue", "B_center_pseudoatom") cmd.show("sphere", "B_N_term") cmd.color("cyan", "B_N_term") cmd.show("sphere", "B_C_term") cmd.color("B_C_term_color", "B_C_term") # nice output cmd.rebuild() cmd.zoom("all") cmd.png("%s/%s.png" % (OUTPUT_FOLDER_PNG, this_PDB_file), quiet=1) # save session cmd.save("%s/%s.pse" % (OUTPUT_FOLDER_SESSION, this_PDB_file))
def label_chains(selection): """ DESCRIPTION Detect and label chains USAGE label_chains selection ARGUMENTS selection = name of the selection on which to operate. Atoms outside the selection won't be changed """ chainlabels = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' cmd.alter(selection, 'chain=""') for label in chainlabels: space = {'stored': []} cmd.iterate('({}) and (chain "")'.format(selection), 'stored.append(index)', space=space) unnamedindices = space['stored'] if not unnamedindices: break cmd.alter( '({}) and (bymol (({}) and index {}))'.format( selection, selection, unnamedindices[0]), 'chain="{}"'.format(label)) cmd.sort()
def RefreshDisplay(self): try: # Display the atoms spheres cmd.show('spheres', self.LigDisplay) cmd.refresh() cmd.alter(self.LigDisplay,'vdw=0.25') cmd.rebuild(self.LigDisplay) cmd.refresh() util.cbag(self.LigDisplay) cmd.refresh() if self.AnchorAtom != -1: AtomSel = self.LigDisplay + ' & id ' + str(self.AnchorAtom) cmd.color('white',AtomSel) cmd.refresh() cmd.alter(AtomSel ,'vdw=0.30') cmd.rebuild(AtomSel) cmd.refresh() except: self.ErrorCode = 1 return self.ErrorCode
def test_sets_ranges(self): cmd.fab('ACDEFGHIKL') cmd.alter('resi 9', 'resi="9A"') # insertion code self.assertEqual(3, cmd.count_atoms('guide & resi 2-4')) self.assertEqual(3, cmd.count_atoms('guide & resi 2:4')) self.assertEqual(2, cmd.count_atoms('guide & resi 2+4')) self.assertEqual(4, cmd.count_atoms('guide & resi 2-4+6')) self.assertEqual(6, cmd.count_atoms('guide & resi 2-4+6-8')) self.assertEqual(0, cmd.count_atoms('guide & resi 9')) self.assertEqual(1, cmd.count_atoms('guide & resi 9A')) self.assertEqual(1, cmd.count_atoms('guide & resi 10')) self.assertEqual(0, cmd.count_atoms('guide & resi 10A')) self.assertEqual(2, cmd.count_atoms('guide & resi 9-10')) self.assertEqual(2, cmd.count_atoms('guide & resi 9A-10A')) self.assertEqual(10 + 9, cmd.count_atoms('name CA+CB')) self.assertEqual(10 + 9, cmd.count_atoms('name CA+CB+XYZ')) self.assertEqual(10, cmd.count_atoms('name C')) self.assertEqual(50, cmd.count_atoms('name C*')) self.assertEqual(10, cmd.count_atoms('name H')) self.assertEqual(24, cmd.count_atoms('name H*')) self.assertEqual(10, cmd.count_atoms('name *H')) self.assertEqual(74, cmd.count_atoms('name *H*')) self.assertEqual(20, cmd.count_atoms('name C+N')) self.assertEqual(23, cmd.count_atoms('name C+N*')) self.assertEqual(60, cmd.count_atoms('name C*+N')) self.assertEqual(63, cmd.count_atoms('name C*+N*'))
def number_chains(selection='all', numbers='ABCDEFGHIJKLMNOPQRSTUVWXYZ'): """ DESCRIPTION Find chains and number them consecutively USAGE number_chains [selection [, numbers]] ARGUMENTS selection = the selection in which this function operates numbers = list of symbols to be applied. Defaults to capital letters of the ABC """ cmd.alter(selection, 'chain=""') chains = iter(numbers) foundchains = [] logger.debug('Finding chains among {} atoms'.format( cmd.count_atoms(selection))) for idx in iterate_indices(selection): if get_chain(idx, selection): # if this atom already has a chain ID set, continue with the next atom. continue foundchains.append(next(chains)) cmd.alter('(bymol idx {}) and ({})'.format(idx, selection), 'chain="{}"'.format(foundchains[-1])) cmd.sort(selection) logger.debug('Found chains: ' + ', '.join([str(c) for c in foundchains])) return foundchains
def hilightPolar(sel='all'): N = "elem N"# and (not name N)" O = "elem O"# and (not name O)" # want to inlude look BB atoms... S = "elem S" sel = sel + " and " + N+" or "+O+" or "+S cmd.alter(sel,"vdw=0.3") cmd.rebuild() cmd.show('spheres',sel)
def mkc2(sel, a=Vec(0, 0, 1), c=Vec(0, 0, 0)): cmd.delete("c1") cmd.delete("c2") cmd.create("c1", sel) cmd.create("c2", sel) rot("c2", a, 180, c) cmd.alter("c1", 'chain = "A"') cmd.alter("c2", 'chain = "B"')
def colorByProp(self, prop, palette="rainbow"): stored.propUniqVals = set() cmd.iterate(self.objName, "stored.propUniqVals.add(%s)" % prop) v = sorted(stored.propUniqVals) b = n.arange(1, len(v) + 1, dtype=float) # / len(v) stored.b = dict(zip(v, b)) cmd.alter(self.objName, "b=stored.b[%s]" % prop) cmd.spectrum("b", palette, self.objName)
def spectrumproperty(propname, color_list, selection='(all)', minimum=None, maximum=None, quiet=1): ''' DESCRIPTION Define a color spectrum with as many color-stops as you like (at least 2). ARGUMENTS propname = string: property name which has a float value. color_list = string: Space separated list of colors ... all other arguments like with `spectrum` command ''' quiet = int(quiet) colors = color_list.split() if len(colors) < 2: print 'failed! please provide at least 2 colors' return colvec = [cmd.get_color_tuple(i) for i in colors] parts = len(colvec) - 1 value_list = [] cmd.iterate(selection, 'value_list.append(properties[propname])', space=locals()) if len(value_list) == 0: print 'empty selection' return if minimum is None: minimum = min(value_list) if maximum is None: maximum = max(value_list) minimum, maximum = float(minimum), float(maximum) val_range = (maximum - minimum) * (1 + 1e-6) if not quiet: print ' Spectrum: range (%.5f to %.5f)' % (minimum, maximum) if maximum == minimum: print 'no spectrum possible, only equal values' return rgb = lambda i, p, j: int(255 * (colvec[i+1][j] * p + colvec[i][j] * (1.0 - p))) col_list = [] for value in value_list: p = (value - minimum) / val_range * parts i = int(p) p -= i col_list.append(0x40000000 + rgb(i, p, 0) * 0x10000 + rgb(i, p, 1) * 0x100 + rgb(i, p, 2)) cmd.alter(selection, 'color = col_iter.next()', space={'col_iter': iter(col_list)}) cmd.recolor()
def renumber(selection='all', start=1, startsele=None, quiet=1): ''' DESCRIPTION Set residue numbering (resi) based on connectivity. ARGUMENTS selection = string: atom selection to renumber {default: all} start = integer: counting start {default: 1} startsele = string: residue to start counting from {default: first in selection} ''' start, quiet = int(start), int(quiet) model = cmd.get_model(selection) cmd.iterate(selection, 'atom_it.next().model = model', space={'atom_it': iter(model.atom)}) if startsele is not None: startidx = cmd.index('first (' + startsele + ')')[0] for atom in model.atom: if (atom.model, atom.index) == startidx: startatom = atom break else: print(' Error: startsele not in selection') raise CmdException else: startatom = model.atom[0] for atom in model.atom: atom.adjacent = [] atom.visited = False for bond in model.bond: atoms = [model.atom[i] for i in bond.index] atoms[0].adjacent.append(atoms[1]) atoms[1].adjacent.append(atoms[0]) minmax = [start, start] def traverse(atom, resi): atom.resi = resi atom.visited = True for other in atom.adjacent: if other.visited: continue if (atom.name, other.name) in [('C', 'N'), ("O3'", 'P')]: minmax[1] = resi + 1 traverse(other, resi + 1) elif (atom.name, other.name) in [('N', 'C'), ('P', "O3'")]: minmax[0] = resi - 1 traverse(other, resi - 1) elif (atom.name, other.name) not in [('SG', 'SG')]: traverse(other, resi) traverse(startatom, start) cmd.alter(selection, 'resi = atom_it.next().resi', space={'atom_it': iter(model.atom)}) if not quiet: print(' Renumber: range (%d to %d)' % tuple(minmax))
def test_sort(self): cmd.pseudoatom('m1', name='PS2') cmd.pseudoatom('m1', name='PS1') cmd.alter('all', 'name = name_list.pop()', space={'name_list': ['PS1', 'PS2']}) v = [a.name for a in cmd.get_model().atom] self.assertEqual(['PS2', 'PS1'], v) cmd.sort() v = [a.name for a in cmd.get_model().atom] self.assertEqual(['PS1', 'PS2'], v)
def makecx(sel="all", n=5): cmd.delete("C%i_*" % n) chains = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" for i in range(n): cmd.create("C%i_%i" % (n, i), sel + " and (not C%i_*)" % n) for i in range(n): rot("C%i_%i" % (n, i), Z, 360.0 * float(i) / float(n)) for i in range(n): cmd.alter("C%i_%i" % (n, i), "chain = '%s'" % chains[i])
def build(object_name, sequence, first_residue = "1"): if len(sequence): code = sequence[0] cmd.fragment(aa_dict[code],object_name) cmd.alter(object_name,'resi="%s"'%first_residue) cmd.edit(object_name+" and name C") for code in sequence[1:]: editor.attach_amino_acid("pk1",aa_dict[code]) cmd.edit()
def testMacros(self): ''' Test selection macros: /model/segi/chain/resn`resi/name`alt See also tests/jira/PYMOL-2720.py ''' cmd.load(self.datafile("1oky.pdb.gz"), "m1") cmd.alter('*', 'segi="X"') cmd.alter('resi 200-238', 'chain="B"') cmd.alter('resi 239-360', 'chain="C"') cmd.alter('resi 150-220', 'segi="Y"') cmd.alter('resi 220-', 'segi="Z"') # all atoms self.assertEqual(cmd.count_atoms('/'), cmd.count_atoms()) self.assertEqual(cmd.count_atoms('/////'), cmd.count_atoms()) # model self.assertEqual(cmd.count_atoms('/m1'), cmd.count_atoms('all')) self.assertEqual(cmd.count_atoms('m1////'), cmd.count_atoms('all')) # segi self.assertEqual(cmd.count_atoms('//Y'), cmd.count_atoms('segi Y')) self.assertEqual(cmd.count_atoms('//Y+Z'), cmd.count_atoms('segi Y+Z')) # chains self.assertEqual(cmd.count_atoms('///B'), cmd.count_atoms('chain B')) self.assertEqual(cmd.count_atoms('///A+B'), cmd.count_atoms('chain A+B')) # resn/resi self.assertEqual(cmd.count_atoms('////100'), cmd.count_atoms('resi 100')) self.assertEqual(cmd.count_atoms('////`100'), cmd.count_atoms('resi 100')) self.assertEqual(cmd.count_atoms('////100-110'), cmd.count_atoms('resi 100-110')) self.assertEqual(cmd.count_atoms('////ARG`100'), cmd.count_atoms('resi 100')) self.assertEqual(cmd.count_atoms('////ALA'), cmd.count_atoms('resn ALA'), ) self.assertEqual(cmd.count_atoms('ALA/'), cmd.count_atoms('resn ALA'), ) self.assertEqual(cmd.count_atoms('////ALA`'), cmd.count_atoms('resn ALA')) self.assertEqual(cmd.count_atoms('////ALA+GLU'), cmd.count_atoms('resn ALA+GLU'), ) # name/alt self.assertEqual(cmd.count_atoms('/////CG'), cmd.count_atoms('name CG')) self.assertEqual(cmd.count_atoms('*/CG'), cmd.count_atoms('name CG')) self.assertEqual(cmd.count_atoms('/////CG`B'), cmd.count_atoms('name CG & alt B')) self.assertEqual(cmd.count_atoms('/////`B'), cmd.count_atoms('alt B')) # combies self.assertEqual(cmd.count_atoms('100/CA'), cmd.count_atoms('resi 100 & name CA')) self.assertEqual(cmd.count_atoms('A//CA'), cmd.count_atoms('chain A & name CA')) self.assertEqual(cmd.count_atoms('A//`B'), cmd.count_atoms('chain A & alt B')) self.assertEqual(cmd.count_atoms('/m1/Y/B/*/CA'), cmd.count_atoms('segi Y & chain B & name CA')) # or-logic ref = cmd.count_atoms('(resi 100 & name CA) (resi 110 & name CB)') self.assertEqual(cmd.count_atoms('100/CA|110/CB'), ref) self.assertEqual(cmd.count_atoms('100/CA or 110/CB'), ref) self.assertEqual(cmd.count_atoms('100/CA 110/CB'), ref)
def load_weights(): file_weights = open_it() i = 0 for line in open(file_weights, "r"): i = i + 1 selec = "resi " + str(i) ocup = line.split() cmd.alter(selec, "b=" + ocup[0]) cmd.spectrum("b", "blue_red")
def test_remove_alt(): cmd.reinitialize() cmd.fab('AC', 'm1') cmd.alter('resn ALA', 'alt="A"') cmd.alter('resn CYS', 'alt="B"') cmd.create('m2', 'm1') psico.editing.remove_alt('m1') psico.editing.remove_alt('m2', keep='B') assert cmd.count_atoms('m1') == 10 assert cmd.count_atoms('m2') == 11
def aaindex2b(key, selection='all', var='b', quiet=1): ''' DESCRIPTION Looks up the Amino Acid Index from http://www.genome.jp/aaindex/ for the given key and assignes b-factors to the given selection. Unknown residues get the average index value assigned. USAGE aaindex2b key [, selection ] ARGUMENTS key = string: Key of AAindex entry selection = string: atoms to assign b-factors {default: (all)} EXAMPLE # Hydropathy index by Kyte-Doolittle aaindex2b KYTJ820101 spectrumany b, white yellow forest show surface SEE ALSO hydropathy2b ''' _assert_package_import() from . import one_letter quiet = int(quiet) aaindex = _get_aaindex1() try: entry = aaindex[key] except KeyError: print(' Error: No such key in AAindex:', key) raise CmdException median = entry.median() if not quiet: print(entry.desc.strip()) def lookup(resn): aa = one_letter.get(resn, 'X') value = entry.get(aa) if value is None: return median return value cmd.alter(selection, var + '=lookup(resn)', space=locals())
def ens_prob(): print '\n\nEnsemble probability options' # get models, mean coords models = [] selection = 'all' for i in range(cmd.count_states(selection)): models.append(cmd.get_model(selection,state=i+1)) for n, model in enumerate(models): residues = model.get_residues() for residue in residues: # Get individual atom info q_list = [] q_list_mc = [] q_list_sc = [] for i_seq in range (residue[0], residue[1]): # Ignore hydrogens if model.atom[i_seq].symbol != 'H': q_list.append(float(model.atom[i_seq].q)) if model.atom[i_seq].name in ['N','CA','C','O']: q_list_mc.append(float(model.atom[i_seq].q)) else: q_list_sc.append(float(model.atom[i_seq].q)) # Set probability per residue # Mean p if len(q_list) > 0: p_new = sum(q_list) / len(q_list) if len(q_list_mc) > 0: p_new_mc = sum(q_list_mc) / len(q_list_mc) if len(q_list_sc) > 0: p_new_sc = sum(q_list_sc) / len(q_list_sc) # # Joint p_new = q_list[0] for p in q_list[1:]: p_new *= p # # nll # p_new = math.log(q_list[0]) # for p in q_list[1:]: # p_new += math.log(max(p,0.001)) # p_new *= -1 if i_seq == residue[1]-1: for i_seq in range (residue[0], residue[1]): if True: atom_sel = 'id ' + str(model.atom[i_seq].id) + ' and state ' + str(n+1) atom_action = 'b = ' + str(p_new) cmd.alter(atom_sel, atom_action) else: atom_sel = 'id ' + str(model.atom[i_seq].id) + ' and state ' + str(n+1) if model.atom[i_seq].name in ['N','CA','C','O']: atom_action = 'b = ' + str(p_new_mc) else: atom_action = 'b = ' + str(p_new_sc) cmd.alter(atom_sel, atom_action)
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"])