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
Beispiel #2
0
def load():
    cmd.set("valence")
    r = 0
    list = glob("pdb/*/*")
    (x, y, z) = (0, 0, 0)
    start = time.time()
    count = 1
    scale = 100.0
    for file in list:
        cmd.load(file, str(count), quiet=1)
        cmd.translate([x * scale, y * scale, z * scale], object=str(count))
        #      cmd.disable(str(count))
        atoms = cmd.count_atoms()
        passed = time.time() - start
        print "%3d structures/%5.1f sec = %8.1f atom/sec over %6d atoms" % (
            count, passed, atoms / passed, atoms)
        count = count + 1
        if count > 100: break
        x = x + 1
        if x > 7:
            x = 0
            y = y + 1
            if y > 7:
                y = 0
                z = z + 1
                if z > 9:
                    y = 0
                    z = z + 1
    cmd.zoom()
    cmd.set("sphere_mode", 1)
    cmd.show_as("spheres")
    cmd.rebuild()
    cmd.set("hash_max", 250)
Beispiel #3
0
 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)
Beispiel #4
0
    def displaySphere(self):

        try:
            cmd.delete(self.SphereDisplay)
            cmd.refresh()
        except:
            pass

        if self.Sphere != None:
            # Only display sphere in current state
            cmd.pseudoatom(self.SphereDisplay,
                           pos=self.Sphere.Center,
                           vdw=self.Sphere.Radius,
                           color='purpleblue',
                           state=cmd.get_state())
            cmd.refresh()

            cmd.hide('nonbonded', self.SphereDisplay)
            cmd.refresh()

            cmd.show('spheres', self.SphereDisplay)
            cmd.refresh()

            cmd.set('sphere_transparency', 0.7, self.SphereDisplay)
            cmd.rebuild(self.SphereDisplay)
Beispiel #5
0
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()
Beispiel #6
0
    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
Beispiel #7
0
def load():
   cmd.set("valence")
   r = 0
   list = glob("pdb/*/*")
   (x,y,z)=(0,0,0)
   start = time.time()
   count = 1
   scale = 100.0
   for file in list:
      cmd.load(file,str(count),quiet=1)
      cmd.translate([x*scale,y*scale,z*scale],object=str(count))
#      cmd.disable(str(count))
      atoms = cmd.count_atoms()
      passed = time.time()-start
      print "%3d structures/%5.1f sec = %8.1f atom/sec over %6d atoms"%(count,passed,atoms/passed,atoms)
      count = count + 1
      if count>100: break
      x = x + 1
      if x>7:
         x = 0
         y = y + 1
         if y>7:
            y = 0
            z = z + 1
            if z>9:
               y = 0
               z = z + 1
   cmd.zoom()
   cmd.set("sphere_mode",1)
   cmd.as("spheres")
   cmd.rebuild()
   cmd.set("hash_max",250)
Beispiel #8
0
def data2q_res(mol='',data_file=''):
  """
  usage: data2q_res <mol>, <data_file>

  where <mol> is the molecular object whose occupancy data you wish to modify
  and <data_file> is a file contain the data (one value for each residue)
  The format of <data_file> should be:

     chain resnum resname data
  or
     resnum resname data

  (i.e. "chain" is optional). Lines beginning with '#' are ignored as comments.  
  """
#  call the function to extract the data per residue from 'data_file'
#  alter 'mol' with it.

  from pymol import cmd

  # read the data file and extract the 
  # data to the q_dict and res_dict dictionaries
  q_dict,res_dict = residue_data_extract(data_file)

  # make lists of chains and residues within the chains and sort them
  chain_list = q_dict.keys()
  chain_list.sort()
  for chain in chain_list:
    res_list = q_dict[chain].keys()
    res_list.sort()
    # now do the alteration of the occupancy (q) data
    for resnum in res_list:
      cmd.do("alter /%s//%s/%s/,q=%f" % (mol,chain,resnum,q_dict[chain][resnum]))

    # force a rebuild of the drawing
    cmd.rebuild()
Beispiel #9
0
    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
Beispiel #10
0
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()
Beispiel #11
0
def remap_residues(index_file, sel="polymer"):
    import pandas as pd
    from string import ascii_uppercase as ins
    df = pd.read_csv(index_file, dialect="excel-tab")
    gr_df = df.groupby("id_from")
    for chain, group in gr_df:
        ind = {}
        prev_to_ind = None
        i_ins = 0
        for i_x, x in enumerate(group[["from_ind",
                                       "to_ind"]].itertuples(index=False)):
            item = tuple(str(_) for _ in tuple(x))
            from_ind, to_ind = item
            ## runs of identical to_ind cause insertion codes
            if i_x > 0:
                if to_ind == prev_to_ind:
                    to_ind = to_ind + ins[i_ins]
                    i_ins += 1
                else:
                    i_ins = 0
            if from_ind not in ind:
                ind[from_ind] = to_ind
            prev_to_ind = item[1]

        space = dict(ind_map=ind)
        cmd.alter("{} and chain {}".format(sel, chain),
                  "resi=ind_map[resi]",
                  space=space)
        cmd.rebuild()
        cmd.sort()
Beispiel #12
0
    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
Beispiel #13
0
    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
Beispiel #14
0
def unhilightPolar(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=1.0")
    cmd.rebuild()
    cmd.hide('spheres', sel)
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))
	cmd.rebuild()
Beispiel #16
0
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)
Beispiel #17
0
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))
    cmd.rebuild()
def stride2pymol(mol='', sel=''):
    """
  usage: stride2pymol object, [selection]

  where the object name is required, but the selection is optional 
  (defaults to all of the object).  
  
  e.g. stride2pymol prot, i. 1-300 and c. a
  """
    #Save the specified molecule (and optional selection sel) to a temporary
    #PDB format file and call stride_extract on it

    from pymol import cmd

    # map stride's secondary structure alphabet onto pymol's
    # strides definitions:
    # G = 3/10 helix
    # B = Bridge
    # C = coil
    # T = turn
    # H = helix
    # E = strand/sheet

    # create tmpfile from the selection name and the current time in seconds since the epoch
    ext = str(int(time.time()))
    tmpfile = mol + '.pdb_' + ext
    if sel:
        # make sure that selection forces the molecule name to be included in the selection
        # (i.e. is 'and'-ed with the rest of the selection)
        sel = mol + ' and ' + sel
        cmd.save(tmpfile, sel, 1, 'pdb')
    else:
        cmd.save(tmpfile, mol, 1, 'pdb')
    # run stride on the saved pdb file and read the standard output to extract the
    # data to the sec_dict and res_dict dictionaries
    sec_dict, res_dict = stride_extract(tmpfile)
    os.remove(tmpfile)

    # make lists of chains and residues within the chains and sort them
    chain_list = sec_dict.keys()
    chain_list.sort()
    for chain in chain_list:
        res_list = sec_dict[chain].keys()
        res_list.sort()
        # now do the alteration of the secondary structure.
        for resnum in res_list:
            cmd.do(
                "alter /%s//%s/%s,ss='%s'" %
                (mol, chain, resnum, stride_2_pymol[sec_dict[chain][resnum]]))

        # make sure that cartoon automatic is set for this molecule
        cmd.cartoon('automatic', mol)
        # force a rebuild of the drawing
        cmd.rebuild()
Beispiel #19
0
    def ResizeSphere(self):
        
        self.SphereView.Set_Radius(self.SphereSize.get())

        try:
            cmd.alter(self.SphereDisplay,'vdw=' + str(self.SphereView.Radius))
            cmd.rebuild(self.SphereDisplay)
            cmd.refresh()
        except:
            self.queue.put(lambda: self.App.DisplayMessage("  ERROR: Could not resize the Sphere", 1))
            self.queue.put(lambda: self.App.DisplayMessage("         The wizard will abort prematurely", 1))
            self.Quit_Wizard()
Beispiel #20
0
def stride2pymol(mol='',sel=''):
  """
  usage: stride2pymol object, [selection]

  where the object name is required, but the selection is optional 
  (defaults to all of the object).  
  
  e.g. stride2pymol prot, i. 1-300 and c. a
  """
  #Save the specified molecule (and optional selection sel) to a temporary 
  #PDB format file and call stride_extract on it

  from pymol import cmd

  # map stride's secondary structure alphabet onto pymol's
  # strides definitions:
  # G = 3/10 helix
  # B = Bridge
  # C = coil
  # T = turn
  # H = helix
  # E = strand/sheet

  # create tmpfile from the selection name and the current time in seconds since the epoch
  ext = str(int(time.time()))
  tmpfile=mol + '.pdb_' + ext
  if sel:
    # make sure that selection forces the molecule name to be included in the selection
    # (i.e. is 'and'-ed with the rest of the selection)
    sel = mol + ' and ' + sel
    cmd.save(tmpfile,sel,1,'pdb')
  else:
    cmd.save(tmpfile,mol,1,'pdb')
  # run stride on the saved pdb file and read the standard output to extract the 
  # data to the sec_dict and res_dict dictionaries
  sec_dict,res_dict = stride_extract(tmpfile)
  os.remove(tmpfile)

  # make lists of chains and residues within the chains and sort them
  chain_list = sec_dict.keys()
  chain_list.sort()
  for chain in chain_list:
    res_list = sec_dict[chain].keys()
    res_list.sort()
    # now do the alteration of the secondary structure.
    for resnum in res_list:
      cmd.do("alter /%s//%s/%s,ss='%s'" % (mol,chain,resnum,stride_2_pymol[sec_dict[chain][resnum]]))

    # make sure that cartoon automatic is set for this molecule
    cmd.cartoon('automatic',mol)
    # force a rebuild of the drawing
    cmd.rebuild()
Beispiel #21
0
def _common_ss_alter(selection, ss_dict, ss_map, raw=''):
    '''
DESCRIPTION

    Shared code of 'dssp' and 'stride' functions.
    '''
    if raw != 'ss':
        cmd.alter(selection, 'ss = ss_map.get(ss_dict.get((model,chain,resi)), "")',
                space={'ss_dict': ss_dict, 'ss_map': ss_map})
    if raw != '':
        cmd.alter(selection, raw + ' = ss_dict.get((model,chain,resi), "")',
                space={'ss_dict': ss_dict})
    cmd.rebuild(selection, 'cartoon')
Beispiel #22
0
def data2b_atom(mol='', data_file='', prop='b', quiet=0):
    """
DESCRIPTION

    Alters the B-factor data by atom.

USAGE

    data2b_atom <mol>, <data_file>

    where <mol> is the molecular object whose B-factor data you wish to modify
    and <data_file> is a file contain the data (one value for each atom)
    The format of <data_file> should be:

         chain resi resn name data
    or
         resi resn name data

    or
         ID data

    (i.e. "chain" is optional if all atoms are in one chain).
    Lines beginning with '#' are ignored as comments.

SEE ALSO

    data2b_res, data2q_atom, data2q_res
    """

    b_dict = atom_data_extract(data_file)
    quiet = int(quiet) == 1

    def b_lookup(chain, resi, name, ID, b):
        def _lookup(chain, resi, name, ID):
            if resi in b_dict[chain] and isinstance(b_dict[chain][resi], dict):
                return b_dict[chain][resi][name][0]
            else:
                # find data by ID
                return b_dict[chain][int(ID)][0]
        try:
            if not chain in b_dict:
                chain = ''
            b = _lookup(chain, resi, name, ID)
            if not quiet: print '///%s/%s/%s new: %f' % (chain, resi, name, b)
        except KeyError:
            if not quiet: print '///%s/%s/%s keeping: %f' % (chain, resi, name, b)
        return b
    stored.b = b_lookup

    cmd.alter(mol, '%s=stored.b(chain, resi, name, ID, %s)' % (prop, prop))
    cmd.rebuild()
Beispiel #23
0
def _common_ss_alter(selection, ss_dict, ss_map, raw=''):
    '''
DESCRIPTION

    Shared code of 'dssp' and 'stride' functions.
    '''
    if raw != 'ss':
        cmd.alter(selection, 'ss = ss_map.get(ss_dict.get((model,chain,resi)), "")',
                space={'ss_dict': ss_dict, 'ss_map': ss_map})
    if raw != '':
        cmd.alter(selection, raw + ' = ss_dict.get((model,chain,resi), "")',
                space={'ss_dict': ss_dict})
    cmd.cartoon('auto', selection)
    cmd.rebuild(selection, 'cartoon')
Beispiel #24
0
def zero_residues_sub(sel1, start=0, end=0, offset=0, chains=0):
    """
DESCRIPTION

    Renumbers the residues so that the given residue range starts at zero, or offset

USAGE

    zero_residues_sub selection, start, end [, offset [, chains ]]

EXAMPLES

    zero_residues_sub protName, 0, 10            # first residue is 0
    zero_residues_sub protName, 0, 10, 5         # first residue is 5
    zero_residues_sub protName, 0, 10, chains=1  # each chain starts at 0
    zero_residues_sub *
        """
    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:
        if not ok:
            continue
        # reassign the residue numbers
        p = p + " and resi " + start + "-" + end
        cmd.alter("%s" % p,
                  "resi=str(int(resi)-%s)" % str(int(start) - offset))
        # update pymol

    cmd.rebuild()
Beispiel #25
0
    def Display_BindingSite(self):

        auto_zoom = cmd.get("auto_zoom")
        cmd.set("auto_zoom", 0)

        self.Delete_BindingSite()

        try:
            if self.Vars.BindingSite.Type == 1:

                cmd.pseudoatom(self.BindingSiteDisplay,
                               pos=self.Vars.BindingSite.Sphere.Center,
                               vdw=self.Vars.BindingSite.Sphere.Radius,
                               state=1)
                cmd.refresh()

                cmd.hide('everything', self.BindingSiteDisplay)
                cmd.refresh()

                cmd.show('spheres', self.BindingSiteDisplay)
                cmd.refresh()

                cmd.set('sphere_transparency', 0.7, self.BindingSiteDisplay)
                cmd.color('purpleblue', self.BindingSiteDisplay)
                cmd.refresh()

            elif self.Vars.BindingSite.Type == 2 and self.Vars.BindingSite.listClefts:
                self.Generate_CleftBindingSite()

                cmd.load(self.CleftTmpPath, self.BindingSiteDisplay, state=1)
                cmd.refresh()

                cmd.hide('everything', self.BindingSiteDisplay)
                cmd.refresh()

                cmd.show('mesh', self.BindingSiteDisplay)
                cmd.refresh()

                cmd.alter(self.BindingSiteDisplay, 'vdw=2.00')
                cmd.rebuild(self.BindingSiteDisplay)
                cmd.color('purpleblue', self.BindingSiteDisplay)
                cmd.refresh()
            # cmd.color('purpleblue', self.BindingSiteDisplay)
            # cmd.refresh()

        except:
            self.DisplayMessage("  ERROR: while displaying the binding-site",
                                2)

        cmd.set("auto_zoom", auto_zoom)
Beispiel #26
0
    def ResizeSphere(self):

        self.SphereView.Set_Radius(self.SphereSize.get())

        try:
            cmd.alter(self.SphereDisplay, 'vdw=' + str(self.SphereView.Radius))
            cmd.rebuild(self.SphereDisplay)
            cmd.refresh()
        except:
            self.queue.put(lambda: self.App.DisplayMessage(
                "  ERROR: Could not resize the Sphere", 1))
            self.queue.put(lambda: self.App.DisplayMessage(
                "         The wizard will abort prematurely", 1))
            self.Quit_Wizard()
Beispiel #27
0
def _common_ss_alter(selection, ss_dict, ss_map, raw=""):
    """
DESCRIPTION

    Shared code of 'dssp' and 'stride' functions.
    """
    if raw != "ss":
        cmd.alter(
            selection,
            'ss = ss_map.get(ss_dict.get((model,chain,resi)), "")',
            space={"ss_dict": ss_dict, "ss_map": ss_map},
        )
    if raw != "":
        cmd.alter(selection, raw + ' = ss_dict.get((model,chain,resi), "")', space={"ss_dict": ss_dict})
    cmd.rebuild(selection, "cartoon")
Beispiel #28
0
def data2b_res(mol='', data_file='', property='b', quiet=0):
    """
DESCRIPTION

    Alters the B-factor data by residue.

USAGE

    data2b_res <mol>, <data_file>

    where <mol> is the molecular object whose B-factor data you wish to modify
    and <data_file> is a file contain the data (one value for each residue)
    The format of <data_file> should be:

         chain resi resn data
    or
         resi resn data
    or
         resi data

    (i.e. "chain" is optional). Lines beginning with '#' are ignored as comments.

SEE ALSO

    data2b_atom, data2q_atom, data2q_res
    """

    b_dict = residue_data_extract(data_file)
    quiet = int(quiet) == 1

    def b_lookup(chain, resi, name, b):
        try:
            if chain in b_dict:
                b = b_dict[chain][resi][0]
            else:
                b = b_dict[''][resi][0]
            if not quiet: print '///%s/%s/%s new: %f' % (chain, resi, name, b)
        except KeyError:
            if not quiet:
                print '///%s/%s/%s keeping: %f' % (chain, resi, name, b)
        return b

    stored.b = b_lookup

    cmd.alter(mol, '%s=stored.b(chain, resi, name, %s)' % (property, property))
    cmd.rebuild()
Beispiel #29
0
 def assign_with_ksdssp(self):
     # Runs ksdssp.
     ksdssp_fp = self.pymod.ksdssp["exe_file_path"].get_value()
     input_filepath = os.path.join(self.pymod.structures_dirpath,
                                   self.pymod_element.get_structure_file())
     dssptext = self.runKSDSSP(input_filepath, ksdssp_exe=ksdssp_fp)
     # Parses ksdssp's output, that is, an series of pdb format 'HELIX' and 'SHEET' record lines.
     dsspout = dssptext.split("\n")
     helices = set(
     )  # A set to store the sequence numbers of the residues in helical conformation.
     sheets = set(
     )  # A set to store the sequence numbers of the residues in sheet conformation.
     for line in dsspout:
         if line.startswith("HELIX"):
             new_residues_set = set(
                 range(int(line[21:25]),
                       int(line[33:37]) + 1))
             helices.update(new_residues_set)
         elif line.startswith("SHEET"):
             new_residues_set = set(
                 range(int(line[22:26]),
                       int(line[33:37]) + 1))
             sheets.update(new_residues_set)
     # Assigns to the PyMod element the observed secondaey structure observed using ksdssp.
     for residue in self.pymod_element.get_polymer_residues():
         if residue.db_index in helices:
             self.assign_sec_str_to_residue(residue, "H")
             rsel = residue.get_pymol_selector()
             cmd.alter(
                 rsel,
                 "ss='H'")  # Set the residue new conformation in PyMOL.
         elif residue.db_index in sheets:
             self.assign_sec_str_to_residue(residue, "S")
             rsel = residue.get_pymol_selector()
             cmd.alter(
                 rsel,
                 "ss='S'")  # Set the residue new conformation in PyMOL.
         else:
             self.assign_sec_str_to_residue(residue, "L")
             rsel = residue.get_pymol_selector()
             cmd.alter(
                 rsel,
                 "ss='L'")  # Set the residue new conformation in PyMOL.
     # Update in PyMOL.
     cmd.rebuild()
Beispiel #30
0
    def DisplayLigand(self):
        
        try:
            cmd.load(self.pdbPath, self.LigDisplay, state=self.State)

            # Display the atoms spheres
            cmd.show('spheres', self.LigDisplay)
            cmd.alter(self.LigDisplay,'vdw=0.25')
            cmd.rebuild(self.LigDisplay)
        
            util.cbag(self.LigDisplay)
            cmd.translate(self.Translation,self.LigDisplay)
            cmd.zoom(self.LigDisplay)

        except:
            return 1

        return 0
Beispiel #31
0
def data2b_res(mol='', data_file='', prop='b', quiet=0):
    """
DESCRIPTION

    Alters the B-factor data by residue.

USAGE

    data2b_res <mol>, <data_file>

    where <mol> is the molecular object whose B-factor data you wish to modify
    and <data_file> is a file contain the data (one value for each residue)
    The format of <data_file> should be:

         chain resi resn data
    or
         resi resn data
    or
         resi data

    (i.e. "chain" is optional). Lines beginning with '#' are ignored as comments.

SEE ALSO

    data2b_atom, data2q_atom, data2q_res
    """

    b_dict = residue_data_extract(data_file)
    quiet = int(quiet) == 1

    def b_lookup(chain, resi, name, b):
        try:
            if chain in b_dict:
                b = b_dict[chain][resi][0]
            else:
                b = b_dict[''][resi][0]
            if not quiet: print '///%s/%s/%s new: %f' % (chain, resi, name, b)
        except KeyError:
            if not quiet: print '///%s/%s/%s keeping: %f' % (chain, resi, name, b)
        return b
    stored.b = b_lookup

    cmd.alter(mol, '%s=stored.b(chain, resi, name, %s)' % (prop, prop))
    cmd.rebuild()
Beispiel #32
0
def cbs(selection='all', first_color=2, quiet=1):
    '''
DESCRIPTION

    Color by segment
    '''
    import itertools
    if isinstance(first_color, str) and first_color.endswith('s'):
        colors = get_color_family(first_color)
        col_it = itertools.cycle(colors)
    else:
        col_it = itertools.count(int(first_color))
    segi_colors = dict()
    def callback(segi):
        if segi not in segi_colors:
            segi_colors[segi] = next(col_it)
        return segi_colors[segi]
    cmd.alter(selection, 'color = callback(segi)', space=locals())
    cmd.rebuild()
def beautify_images(protein_name, residue_sets):
    cmd.delete("all")

    cmd.fetch(protein_name, async_=0)
    cmd.color(
        "0xFFFFFF"
    )  # colors the entire protein white (so that the predictions can be colored)

    cmd.hide("lines")
    cmd.hide("spheres")
    cmd.show("cartoon")

    sphere_size = f"vdw={SPHERE_SIZE}"  # the size of the rendered sphere

    for res_set in residue_sets:
        cmd.color(res_set.color,
                  res_set.selection_string)  # colors annotated blue
        cmd.show("spheres", res_set.selection_string)
        cmd.alter(res_set.selection_string,
                  sphere_size)  # changes the sphere size

    cmd.rebuild()  # rerenders the spheres to the new size

    # cmd.color(annotated.color, annotated.selection_string) # colors annotated blue
    # cmd.color(wrong.color, wrong.selection_string) # colors wrongly predicted red
    # cmd.color(correct.color, correct.selection_string) # colors correctly predicted green

    # cmd.show("spheres", annotated.selection_string)
    # cmd.show("spheres", correct.selection_string)
    # cmd.show("spheres", wrong.selection_string)

    # cmd.alter(wrong.selection_string, sphere_size)    # changes the sphere size
    # cmd.alter(correct.selection_string, sphere_size)
    # cmd.alter(annotated.selection_string, sphere_size)
    # cmd.rebuild() # rerenders the spheres to the new size

    cmd.remove("resn hoh")  # removes the HOH's from image
    cmd.orient(residue_sets[0].selection_string)
    cmd.zoom(complete=1)
    cmd.set("depth_cue", "0")  # removes shadows of depth
    cmd.center(protein_name)
Beispiel #34
0
def alphaToAll(sel, col="b", forceRebuild=False):
    """
	alphaToAll -- expand any property of the alpha carbons to all atoms in the residue
	
	PARAMS
		sel
			The selection or object (include "*" for all objects) to operate on.  This will
			read the alpha carbon's "COL" property and expand that down to all atoms in the
			given residues in sel.
			
		col
			Any valid PyMOL property.  For example, 'b' or 'q' or 'color', etc.
			DEFAULT: b, for B-factor as we most often overwrite that column
			
		forceRebuild
			If a color changes, this will rebuild the objects for us.  For speed, we
			DEFAULT this to False.
			
	RETURNS
		None, just epxands the properties as dicsussed above.
		
	NOTES
		This script is useful for instances where we update the b-factor column for the
		alpha carbons and then want to expand that color to all atoms for smoother looking
		images.
		
	AUTHOR:
		Jason Vertrees, 2009.
			
	"""
    col = '(' + ','.join(col.split()) + ')'
    space = {'props': dict()}
    cmd.iterate('byca (%s)' % (sel),
                'props[model,segi,chain,resi] = ' + col,
                space=space)
    cmd.alter(sel,
              col + ' = props.get((model,segi,chain,resi), ' + col + ')',
              space=space)
    if forceRebuild != False:
        cmd.rebuild(sel)
Beispiel #35
0
    def displaySphere(self):
        
        try:
            cmd.delete(self.SphereDisplay)
            cmd.refresh()
        except:
            pass
        
        if self.Sphere != None:
            # Only display sphere in current state
            cmd.pseudoatom(self.SphereDisplay, pos=self.Sphere.Center, vdw=self.Sphere.Radius,
                           color='purpleblue', state=cmd.get_state())
            cmd.refresh()

            cmd.hide('nonbonded',self.SphereDisplay)
            cmd.refresh()
            
            cmd.show('spheres', self.SphereDisplay)
            cmd.refresh()
            
            cmd.set('sphere_transparency', 0.7, self.SphereDisplay)
            cmd.rebuild(self.SphereDisplay)
Beispiel #36
0
def data2b_atom(mol='',data_file=''):
  """
  usage: data2b_atom <mol>, <data_file>

  where <mol> is the molecular object whose B-factor data you wish to modify
  and <data_file> is a file contain the data (one value for each atom)
  The format of <data_file> should be:

     chain resnum resname name data
  or
     resnum resname name data

  (i.e. "chain" is optional if all atoms are in one chain). 
  Lines beginning with '#' are ignored as comments.  
  """
#  call the function to extract the data per atom from 'data_file'
#  alter 'mol' with it.

  from pymol import cmd

  # read the data file and extract the 
  # data to the b_dict and res_dict dictionaries
  b_dict,res_dict = atom_data_extract(data_file)

  # make lists of chains and residues within the chains and sort them
  chain_list = b_dict.keys()
  chain_list.sort()
  for chain in chain_list:
    res_list = b_dict[chain].keys()
    res_list.sort()
    for resnum in res_list:
        atom_list = b_dict[chain][resnum].keys()
    # now do the alteration of the B-factor data
        for at in atom_list:
          cmd.do("alter /%s//%s/%s/%s/,b=%f" % (mol,chain,resnum,at,b_dict[chain][resnum][at]))

    # force a rebuild of the drawing
    cmd.rebuild()
Beispiel #37
0
def data2b_atom(mol='',data_file=''):
  """
  usage: data2b_atom <mol>, <data_file>

  where <mol> is the molecular object whose B-factor data you wish to modify
  and <data_file> is a file contain the data (one value for each atom)
  The format of <data_file> should be:

     chain resnum resname name data
  or
     resnum resname name data

  (i.e. "chain" is optional if all atoms are in one chain). 
  Lines beginning with '#' are ignored as comments.  
  """
#  call the function to extract the data per atom from 'data_file'
#  alter 'mol' with it.

  from pymol import cmd

  # read the data file and extract the 
  # data to the b_dict and res_dict dictionaries
  b_dict,res_dict = atom_data_extract(data_file)

  # make lists of chains and residues within the chains and sort them
  chain_list = b_dict.keys()
  chain_list.sort()
  for chain in chain_list:
    res_list = b_dict[chain].keys()
    res_list.sort()
    for resnum in res_list:
        atom_list = b_dict[chain][resnum].keys()
    # now do the alteration of the B-factor data
        for at in atom_list:
          cmd.do("alter /%s//%s/%s/%s/,b=%f" % (mol,chain,resnum,at,b_dict[chain][resnum][at]))

    # force a rebuild of the drawing
    cmd.rebuild()
Beispiel #38
0
def Add_VDW(object, radii=""):
    cmd.copy(object + "_vdw", object)
    cmd.alter(object + "_vdw and elem H", "vdw=1.09")
    radii = radii.lower()
    if radii == "cpk" or radii == "bondi":
        # retrieve the data (coords and atomtypes)
        ATOMTYPES = []
        CARTESIANS = []
        atomslist = cmd.get_model(object + "_vdw")
        for i in range(0, len(atomslist.atom)):
            ATOMTYPES.append(atomslist.atom[i].symbol)
            CARTESIANS.append(atomslist.atom[i].coord)
        for i in range(0, len(ATOMTYPES)):
            atomid = i + 1  # careful, pymol numbering starts at 1, but list starts at 0
            cmd.alter(
                "%s_vdw & id %s" % (object, atomid), "vdw=%.2f" %
                atomicModelRadius(ATOMTYPES, CARTESIANS, radii, i))
    cmd.rebuild()
    cmd.set("sphere_scale", 1, object + "_vdw")
    cmd.hide("nonbonded", object + "_vdw")
    cmd.hide("lines", object + "_vdw")
    cmd.hide("sticks", object + "_vdw")
    cmd.set("sphere_transparency", 0.7, object + "_vdw")
Beispiel #39
0
def make_post_fusion_f():
    bu_pdb = "3rrr.pdb1.gz"
    id_pdb = bu_pdb.split(".")[0]
    fasta = id_pdb + "_f.fasta"
    pdb = id_pdb + "_f.pdb"
    cmd.reinitialize()
    cmd.load(bu_pdb, "bu")
    for chain, chain1, chain2 in (("X", "A", "B"), ("Y", "C", "D"), ("Z", "E",
                                                                     "F")):
        cmd.alter("chain {}+{}".format(chain1, chain2),
                  "chain='{}'".format(chain))
        cmd.rebuild()
        renumber_residues("polymer and chain {}".format(chain))
        cmd.rebuild()
    for chain, chain0 in (("F", "X"), ("E", "Y"), ("D", "Z")):
        cmd.alter("chain {}".format(chain0), "chain='{}'".format(chain))
        cmd.rebuild()
        cmd.create(chain, "bu and chain {}".format(chain))
        cmd.rebuild()
    cmd.delete("bu")
    cmd.rebuild()
    cmd.save(fasta, "polymer", format="fasta")
    cmd.save(pdb, "polymer", format="pdb")
def alphaToAll(sel, col="b",forceRebuild=False):
	"""
	alphaToAll -- expand any property of the alpha carbons to all atoms in the residue
 
	PARAMS
		sel
			The selection or object (include "*" for all objects) to operate on.  This will
			read the alpha carbon's "COL" property and expand that down to all atoms in the
			given residues in sel.
 
		col
			Any valid PyMOL property.  For example, 'b' or 'q' or 'color', etc.
			DEFAULT: b, for B-factor as we most often overwrite that column
 
		forceRebuild
			If a color changes, this will rebuild the objects for us.  For speed, we
			DEFAULT this to False.
 
	RETURNS
		None, just epxands the properties as dicsussed above.
 
	NOTES
		This script is useful for instances where we update the b-factor column for the
		alpha carbons and then want to expand that color to all atoms for smoother looking
		images.
 
	AUTHOR:
		Jason Vertrees, 2009.
 
	"""
	col = '(' + ','.join(col.split()) + ')'
	space = {'props': dict()}
	cmd.iterate('byca (%s)' % (sel), 'props[model,segi,chain,resi] = ' + col, space=space)
	cmd.alter(sel, col + ' = props.get((model,segi,chain,resi), ' + col + ')', space=space)
	if forceRebuild != False:
		cmd.rebuild(sel)
Beispiel #41
0
def make_pre_fusion_f():
    bu_pdb = "4jhw.pdb1.gz"
    id_pdb = bu_pdb.split(".")[0]
    fasta = id_pdb + "_f.fasta"
    pdb = id_pdb + "_f.pdb"
    chain_sel = "F"
    cmd.reinitialize()
    cmd.load(bu_pdb, "bu", 2)
    for chain, state in (("F", 2), ("E", 3), ("D", 4)):
        cmd.create(chain, "bu and chain {}".format(chain_sel), state, 1)
        cmd.alter(chain, "chain='{}'".format(chain))
        cmd.rebuild()
        renumber_residues("{} and polymer and chain {}".format(chain, chain))
        cmd.rebuild()
    cmd.delete("bu")
    cmd.rebuild()
    cmd.save(fasta, "polymer", state=1, format="fasta")
    cmd.save(pdb, "polymer", state=1, format="pdb")
Beispiel #42
0
def useTempRadii(sel="all"):
    for ii in range(30):
        radius = "%0.1f" % (float(ii + 1) / 10)
        cmd.alter(sel + " and b=" + radius, "vdw=" + radius)
    cmd.rebuild()
Beispiel #43
0
def disp_mesh( selection='all', color_m='default', hydrogens=0, only=False, limits=5):
    '''
DESCRIPTION

    Adds a mesh to the object
    Has advanced coloring options and automatically accounts for the hydrogens

USEAGE

    disp_mesh [ selection [, color_m [, hydrogens [, only [, limits]]]]]
    disp_mesh selection=all, color_m=default
    disp_mesh selection=all, color_m=white
    disp_mesh selection=all, color_m=putty

PARAMETERS

    NAME=DEFAULT       TYPE    FUNCTION
    selection='all'    <str>   input selection
    color_m='default'  <str>   'default': as current
                               'name': colors by color or ramp called name
                               'putty': b-factor on surface
    hydrogens=0        <int>   -1: remove; 1: add; else: as is
    only=False         <bool>  if True will use show_as; else show
    limits=5           <list or flaot> 
                               applies only if color_m=='putty'
                               sets the b-factor range limits
                               <list> [min,max] # absolute values
                               <float> percentile cutoff (both sides) # relative for each protein
    '''

    try:
        selection='('+selection+')'
        color_m=str(color_m)
        hydrogens=int(hydrogens)
        only=bool(str(only)!='False')
    except:
        print "Input error"
        return False
        
    if hydrogens==1:
        cmd.h_add('%s' %selection)
    if hydrogens==-1:
        cmd.remove('%s and elem H' %selection)

    for p in cmd.get_object_list(selection):
        cmd.set('mesh_width', 0.25, p)
        if (color_m == 'putty'):
            limits=get_b_limits(limits,p)
            if not limits:
                print "Input error (limits must be <list> or <float (<=50)>)!"
                return False

            cmd.set('mesh_color', 'default', p)      
            cmd.spectrum('b', 'rainbow', '(not hetatm) and %s'%p, minimum='%f'%limits[0], maximum='%f'%limits[1], byres=0)     
            print "disp_ss:",p,"displayed in putty mode - mesh as putty - limits=[%.4f,%.4f]"%(limits[0],limits[1])
        else:
            cmd.set('mesh_color', color_m, p)
            print"regular mode - mesh - "+p

        if only:
            cmd.show_as('mesh', '%s and %s'%(selection, p))
        else:
            cmd.show('mesh', '%s and %s'%(selection, p))
        cmd.rebuild()       
Beispiel #44
0
def atmtypenumbers(filename="atmtypenumbers", selection="all", united=1, quiet=1):
    """
DESCRIPTION

    Update VDW radii for the given selection, based on "atmtypenumbers" file.

ARGUMENTS

    filename = str: path to "atmtypenumbers" file

    selection = str: atom selection to update {default: all}

    united = 1: Use united (implicit hydrogens) radii {default}
    united = 0: Use explicit radii

EXAMPLE

    atmtypenumbers /tmp/MSMS-release/atmtypenumbers, united=0
    """
    import re

    united = int(united)
    quiet = int(quiet)

    if united and not quiet and cmd.count_atoms("(%s) and hydro" % (selection)):
        print(" Warning: united=1 but found hydrogens in selection")

    types = {}
    patterns = []

    _true_func = lambda s: True

    def _get_match_func(p):
        if p == "*":
            return _true_func
        return re.compile(p.replace("_", " ") + "$").match

    try:
        handle = open(filename)
    except IOError:
        raise CmdException("can't open file '%s', please provide correct " "filename" % (filename))

    for line in handle:
        fields = line.split()
        for i, field in enumerate(fields):
            if field.startswith("#"):
                fields = fields[:i]
                break
        if not fields:
            continue

        if fields[0] == "radius":
            vdwidx = 4 if united and len(fields) > 4 else 3
            types[fields[1]] = float(fields[vdwidx])
            continue

        patterns.append((_get_match_func(fields[0]), _get_match_func(fields[1]), types[fields[2]]))

    handle.close()

    def callback(resn, name, vdw):
        for p in patterns:
            if p[0](resn) and p[1](name):
                return p[2]
        if not quiet:
            print(" Warning: no match for '%s/%s'" % (resn, name))
        return vdw

    cmd.alter(selection, "vdw = callback(resn, name, vdw)", space={"callback": callback})
    cmd.rebuild(selection)
Beispiel #45
0
def expandRadii(delta=1.0, sel="all"):
    for a in cmd.get_model(sel).atom:
        r = float(a.vdw) + float(delta)
        cmd.alter("index " + ` a.index `, "vdw = " + ` r `)
    cmd.rebuild(sel, "spheres")
def ColorByDisplacementAll(objSel1, objSel2, super1='all', super2='all', doColor="True", doAlign="True", AlignedWhite='yes'):
    # First create backup copies; names starting with __ (underscores) are normally hidden by PyMOL
    tObj1, tObj2, aln = "__tempObj1", "__tempObj2", "__aln"

    if strTrue(doAlign):
        # Create temp objects
        cmd.create(tObj1, objSel1)
        cmd.create(tObj2, objSel2)
        # Align and make create an object aln which indicates which atoms were paired between the two structures
        # Super is must faster than align http://www.pymolwiki.org/index.php/Super
        cmd.super(tObj1 + ' and ' + str(super1), tObj2 + ' and ' + str(super2), object=aln)
        # Modify the original matrix of object1 from the alignment
        cmd.matrix_copy(tObj1, objSel1)
    else:
        # Create temp objects
        cmd.create(tObj1, objSel1)
        cmd.create(tObj2, objSel2)
        # Align and make create an object aln which indicates which atoms were paired between the two structures
        # Super is must faster than align http://www.pymolwiki.org/index.php/Super
        cmd.super(tObj1 + ' and ' + str(super1), tObj2 + ' and ' + str(super2), object=aln)

    # Modify the B-factor columns of the original objects,
    # in order to identify the residues NOT used for alignment, later on
    cmd.alter(objSel1 + " or " + objSel2, "b=-0.2")
    cmd.alter(tObj1 + " or " + tObj2, "chain='A'")
    cmd.alter(tObj1 + " or " + tObj2, "segi='A'")

    # Update pymol internal representations; one of these should do the trick
    cmd.refresh()
    cmd.rebuild()
    cmd.sort(tObj1)
    cmd.sort(tObj2)

    # Create lists for storage
    stored.alnAres, stored.alnBres = [], []

    # Iterate over objects and get resi
    if AlignedWhite == 'yes':
        cmd.iterate(tObj1 + " and not " + aln, "stored.alnAres.append((resi, name))")
        cmd.iterate(tObj2 + " and not " + aln, "stored.alnBres.append((resi, name))")
    else:
        cmd.iterate(tObj1, "stored.alnAres.append((resi, name))")
        cmd.iterate(tObj2, "stored.alnBres.append((resi, name))")

    # Change the B-factors for EACH object
    displacementUpdateBAll(tObj1, stored.alnAres, tObj2, stored.alnBres)

    # Store the NEW B-factors
    stored.alnAnb, stored.alnBnb = [], []
    # Iterate over objects and get b

    if AlignedWhite == 'yes':
        # Iterate over objects which is not aligned
        cmd.iterate(tObj1 + " and not " + aln, "stored.alnAnb.append(b)")
        cmd.iterate(tObj2 + " and not " + aln, "stored.alnBnb.append(b)")
    else:
        # Or Iterate over all objects with CA
        cmd.iterate(tObj1, "stored.alnAnb.append(b)")
        cmd.iterate(tObj2, "stored.alnBnb.append(b)")

    # Get rid of all intermediate objects and clean up
    cmd.delete(tObj1)
    cmd.delete(tObj2)
    cmd.delete(aln)

    # Assign the just stored NEW B-factors to the original objects
    print "Sooon ready. 1 more minute"
    for x in range(len(stored.alnAres)):
        cmd.alter(objSel1 + " and resi " + str(stored.alnAres[x][0]) + " and name " + str(stored.alnAres[x][1]), "b = " + str(stored.alnAnb[x]))
    for x in range(len(stored.alnBres)):
        cmd.alter(objSel2 + " and resi " + str(stored.alnBres[x][0]) + " and name " + str(stored.alnBres[x][1]), "b = " + str(stored.alnBnb[x]))
    cmd.rebuild()
    cmd.refresh()
    cmd.sort(objSel1)
    cmd.sort(objSel2)

    # Provide some useful information
    stored.allRMSDval = []
    stored.allRMSDval = stored.alnAnb + stored.alnBnb
    print "\nColorByDisplacementAll completed successfully."
    print "The MAXIMUM Displacement is: " + str(max(stored.allRMSDval)) + " residue " + str(stored.alnAres[int(stored.allRMSDval.index(max(stored.allRMSDval)))])

    if strTrue(doColor):
        # Showcase what we did
        # cmd.orient()
        # cmd.hide("all")
        cmd.show("sticks", objSel1 + " or " + objSel2)
        # Select the residues not used for alignment; they still have their B-factors as "-0.2"
        cmd.select("notUsedForAln", "b = -0.2")
        # White-wash the residues not used for alignment
        cmd.color("white", "notUsedForAln")
        # Select the residues not in both pdb files; they have their B-factors as "-0.01"
        cmd.select("ResNotInBothPDB", "b = -0.01")
        # White-wash the residues not used for alignment
        cmd.color("black", "ResNotInBothPDB")
        # Color the residues used for alignment according to their B-factors (Displacement values)
        #cmd.spectrum("b", 'rainbow',  "((" + objSel1 + ") or (" + objSel2 +" )) and not notUsedForAln+ResNotInBothPDB")
        cmd.spectrum("b", 'rainbow', "((" + objSel1 + ") or (" + objSel2 + " )) and not (notUsedForAln or ResNotInBothPDB)")
        # Delete the selection of atoms not used for alignment
        # If you would like to keep this selection intact,
        # just comment "cmd.delete" line and
        # uncomment the "cmd.disable" line abowe.
        cmd.disable("notUsedForAln")
        cmd.delete("notUsedForAln")
        cmd.disable("ResNotInBothPDB")
        cmd.delete("ResNotInBothPDB")
        print "\nObjects are now colored by C-alpha displacement deviation."
        print "Blue is minimum and red is maximum..."
        print "White is those residues used in the alignment algorithm. Can be turned off in top of algorithm."
        print "Black is residues that does not exist in both files..."
def disp_mesh(selection='all',
              color_m='default',
              hydrogens=0,
              only=False,
              limits=5):
    '''
DESCRIPTION

    Adds a mesh to the object
    Has advanced coloring options and automatically accounts for the hydrogens

USEAGE

    disp_mesh [ selection [, color_m [, hydrogens [, only [, limits]]]]]
    disp_mesh selection=all, color_m=default
    disp_mesh selection=all, color_m=white
    disp_mesh selection=all, color_m=putty

PARAMETERS

    NAME=DEFAULT       TYPE    FUNCTION
    selection='all'    <str>   input selection
    color_m='default'  <str>   'default': as current
                               'name': colors by color or ramp called name
                               'putty': b-factor on surface
    hydrogens=0        <int>   -1: remove; 1: add; else: as is
    only=False         <bool>  if True will use show_as; else show
    limits=5           <list or flaot>
                               applies only if color_m=='putty'
                               sets the b-factor range limits
                               <list> [min,max] # absolute values
                               <float> percentile cutoff (both sides) # relative for each protein
    '''

    try:
        selection = '(' + selection + ')'
        color_m = str(color_m)
        hydrogens = int(hydrogens)
        only = bool(str(only) != 'False')
    except:
        print("Input error")
        return False

    if hydrogens == 1:
        cmd.h_add('%s' % selection)
    if hydrogens == -1:
        cmd.remove('%s and elem H' % selection)

    for p in cmd.get_object_list(selection):
        cmd.set('mesh_width', 0.25, p)
        if (color_m == 'putty'):
            limits = get_b_limits(limits, p)
            if not limits:
                print("Input error (limits must be <list> or <float (<=50)>)!")
                return False

            cmd.set('mesh_color', 'default', p)
            cmd.spectrum('b',
                         'rainbow',
                         '(not hetatm) and %s' % p,
                         minimum='%f' % limits[0],
                         maximum='%f' % limits[1],
                         byres=0)
            print(
                "disp_ss:", p,
                "displayed in putty mode - mesh as putty - limits=[%.4f,%.4f]"
                % (limits[0], limits[1]))
        else:
            cmd.set('mesh_color', color_m, p)
            print("regular mode - mesh - " + p)

        if only:
            cmd.show_as('mesh', '%s and %s' % (selection, p))
        else:
            cmd.show('mesh', '%s and %s' % (selection, p))
        cmd.rebuild()
def expandRadii(delta=1.0, sel='all'): 
	for a in cmd.get_model(sel).atom:
		r = float(a.vdw) + float(delta) 
		cmd.alter("index "+a.index,'vdw='+r) 
		cmd.rebuild(sel,"spheres")
def useTempRadii(sel="all"):
	for ii in range(30):
		radius = "%0.1f"%(float(ii+1)/10)
		vdw = "%0.1f"%(float(ii+1)/5)
		cmd.alter(sel+" and b="+radius,"vdw="+vdw)
	cmd.rebuild()
def contractRadii(delta=1.0, sel='all'):
	for a in cmd.get_model(sel).atom:	
		r = float(a.vdw) - float(delta)
		cmd.alter("index "+`a.index`,'vdw='+`r`)
	cmd.rebuild(sel,"spheres")