hydrogen_bondifier 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+.*.swp
+*.gemspec
+pkg

data/History

@@ -0,0 +1,9 @@
+== 0.0.2 / 2010-02-10
+
+* switched to system calls using temp files.  Note that Tempfiles on windows do not work at least the way I am trying to use them.
+
+== 0.0.1 / 2009-12
+
+* using pipes
+
+

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2009 Howard Hughes Medical Institute
+Authored by John T. Prince with the help of Kevin Sours and guidance of
+Natalie G. Ahn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,67 @@
+= HydrogenBondifier
+
+Provides a scriptable interface to pymol, a few basic commands for structure information, and an executable for determining hydrogen bond characteristics as would be useful to those doing hydrogen exchange experiments.
+
+== Examples
+
+=== Pymol Interface
+
+    outfile = "file_with_h_added.pdb"
+    Pymol.run do |pm|
+      pm.cmd "load file.pdb, mymodel"
+      pm.cmd "h_add"
+      pm.cmd "save #{outfile}"
+    end
+
+The real power lies in scripting pymol.  Here's an example of extracting out all connections in a model:
+
+    # this script causes pymol to output all atom connections
+    cnx_script = %Q{
+
+    from pymol import cmd
+
+    def all_connections(selection):
+      """
+      USAGE
+
+      all_connections selection
+
+      returns lines: "CONNECTION: id - id"
+      """
+      stored.xs = []
+      cmd.iterate(selection, 'stored.xs.append( index )')
+      for i in stored.xs:
+        selName = "neighbor%s" % i
+        ids = cmd.select(selName, ("%s and neighbor id %s" % (selection, i)))
+        base = "CONNECTION: %s - " % i 
+        to_print = base + "%s"
+        print_string = 'print "' + to_print + '" % index'
+        cmd.iterate(selName, print_string )
+
+    cmd.extend("all_connections", all_connections)
+    }
+    output = Pymol.run(:script => cnx_script) do |pm|
+      pm.cmd "load file.pdb, mymodel"
+      pm.cmd "all_connections mymodel"
+    end
+
+    # now we just parse the output
+    values_of_output_lines = output.map {|line| line.match(/^CONNECTION: (.*)/)[1] }.compact
+    
+    connection_pairs = values_of_output_lines.map do |v| 
+      v.split(' - ').map {|v| v.to_i }.sort
+    end.uniq
+
+=== Basic methods
+
+Some methods have been completely wrapped in a script and parser to deliver desired output:
+
+    # all atomic pairs as atom ids
+    connections = Pymol::Connections.from_pdb("file.pdb")
+
+    # coordinates of the molecules surface
+    surface_coords = Pymol::Surface.from_pdb("file.pdb")
+
+== Copyright
+
+See LICENSE

data/Rakefile

@@ -0,0 +1,54 @@
+
+require 'rubygems'
+require 'rake'
+require 'jeweler'
+require 'rake/testtask'
+# require 'rcov/rcovtask'
+
+NAME = "hydrogen_bondifier"
+WEBSITE_BASE = "website"
+WEBSITE_OUTPUT = WEBSITE_BASE + "/output"
+
+gemspec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.authors = ["John T. Prince"]
+  s.email = "jtprince@gmail.com"
+  s.homepage = "http://jtprince.github.com/" + NAME
+  s.summary = "finds hydrogen bonds using pymol"
+  s.description = "uses pymol"
+  #s.rubyforge_project = 'mspire'
+  # s.add_dependency("ms-core", ">= 0.0.2")
+  # s.add_development_dependency("ms-testdata", ">= 0.18.0")
+  s.add_development_dependency("spec-more")
+  s.files << "VERSION"
+end
+
+Jeweler::Tasks.new(gemspec)
+
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+#Rcov::RcovTask.new do |spec|
+#  spec.libs << 'spec'
+#  spec.pattern = 'spec/**/*_spec.rb'
+#  spec.verbose = true
+#end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  base_rdoc_output_dir = WEBSITE_OUTPUT + '/rdoc'
+  version = File.read('VERSION')
+  rdoc.rdoc_dir = base_rdoc_output_dir + "/#{version}"
+  rdoc.title = NAME + ' ' + version
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec
+
+task :build => :gemspec
+
+# credit: Rakefile modeled after Jeweler's

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/bin/hydrogen_bondifier.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+# Previous users of Insight(?) used a (<60deg acute angle) cutoff (>120 obtuse)
+# and a 2.85, 2.90, or 3.0 Angstrom cutoff for the hydrogen
+
+# see this on hydrogen bond finding in pymol:
+# http://www.mail-archive.com/pymol-users@lists.sourceforge.net/msg06680.html
+
+require 'yaml'
+require 'narray'
+require 'optparse'
+require 'bio/db/pdb'
+require 'pymol/surface'
+require 'pymol/connections'
+require 'pymol/hydrogen_bonds'
+require 'hydrogen_bondifier/utils'
+
+def putsv(*args)
+  puts(*args) if $VERBOSE
+end
+
+opt = {
+  :max_dist => 3.2,
+  :max_angle => 60,
+  :exclude_water => true,
+  :add_hydrogen => true,
+  :delim => ','
+}
+
+$VERBOSE = true
+
+output_postfix = "_hbonds.csv"
+
+opts = OptionParser.new do |op|
+  op.banner = "usage: #{File.basename(__FILE__)} <file>.pdb ..."
+  op.separator "outputs: <file>#{output_postfix}"
+  op.separator " "
+  op.separator "cutoffs: "
+  op.on("-d", "--max-distance <#{opt[:max_dist]}>", Float, "max distance between donor and acceptor") {|v| opt[:max_dist] = v }
+  op.on("-a", "--max-angle <#{opt[:max_angle]}>", Float, "max angle in degrees") {|v| opt[:max_angle] = v }
+
+  op.separator " "
+  op.separator "options: "
+  op.on("--radians", "output angles in radians") {|v| opt[:radians] = v }
+  op.on("--no-exclude-water", "leaves water molecules in the model") {|v| opt[:exclude_water] = false }
+  op.on("--no-add-hydrogen", "can use if pdb contains all hydrogens") {|v| opt[:add_hydrogen] = false }
+  op.on("--aa-to-surf", "outputs min dist to surface for amino acids") {|v| opt[:aa_to_surf] = v }
+  op.on("-q", "--quiet", "no unnecessary output") {|v| $VERBOSE = false }
+  op.separator " "
+  op.separator "    * if pymol executable cannot be found, you can specify it as the value of the" 
+  op.separator "      environmental variable 'PYMOL_EXE'"
+  op.separator "    * your working directory should be writeable and directory with file"
+  op.separator "    * in output: D=donor, H=hydrogen, A=acceptor"
+end
+
+opts.parse!
+
+if ARGV.size == 0
+  puts opts
+  exit
+end
+
+files = ARGV.map
+ARGV.clear
+
+categories = %w(D_id H_id A_id H_name D_res D_res_id D_name A_res A_res_id A_name angle D_A_dist H_A_dist H_dist_to_surf)
+
+files.each do |file|
+  
+  ####################
+  # need to implement copying of file, etc......
+  ####################
+
+  # create filenames for output files
+  base = file.chomp(File.extname(file))
+
+  pdb_with_hydrogens = 
+    if opt[:add_hydrogen]
+      pdb_plus_h_added = base + '_Hadded.pdb'
+      putsv "writing to: #{pdb_plus_h_added}"
+      Pymol::HydrogenBonds.pdb_with_hydrogens(file, pdb_plus_h_added)
+    else
+      file
+    end
+
+  base_h_added = pdb_with_hydrogens.chomp(File.extname(pdb_with_hydrogens))
+
+  hbond_arrays = Pymol::HydrogenBonds.from_pdb(pdb_with_hydrogens, opt)
+
+  # http://pymolwiki.org/index.php/Surface#Exporting_Surface.2FMesh_Coordinates_to_File
+  surface_coords = Pymol::Surface.from_pdb(pdb_with_hydrogens)
+
+  sc_sz = surface_coords.size
+  (xs, ys, zs) = [nil,nil,nil].map { NArray.float(sc_sz) }
+  surface_coords.each_with_index do |xyz, i|
+    xs[i] = xyz[0]
+    ys[i] = xyz[1]
+    zs[i] = xyz[2]
+  end
+
+  # get the distance from hydrogen to surface
+  # 0 => donor
+  # 1 => hydrogen
+  # 2 => acceptor
+  which_atom = 1
+
+  # just output distance to the surface of the amino acid
+  if opt[:aa_to_surf]
+    amino_acids = []
+    hbond_arrays.each do |a,b,c|
+      [a,c].each {|atom| amino_acids << atom.residue }
+    end
+    amino_acids.uniq.each do |res|
+
+      #### CENTER OF GRAVITY
+      #coord = res.centreOfGravity
+      #### GEOMETRIC CENTER
+      #coord = res.geometricCentre
+      #min_dist = Bio::PDB::Utils.distance_to_many(coord, [xs, ys, zs] ).min
+
+      #### MINIMUM DISTANCE TO ANY ATOM
+      min_dist = res.atoms.map {|atom| Bio::PDB::Utils.distance_to_many(atom.xyz, [xs, ys, zs] ).min }.min
+      # output to mimic older output
+      puts "#{res.resName}#{res.id} minimum_distance_to_surface #{min_dist}"
+    end
+
+    next
+  end
+
+  putsv "calculating distances to surface ..."
+  # also we are gathering all the data we need.
+  characterized = hbond_arrays.map do |data|
+    coords = Array.new(3)
+    na_coords = Array.new(3)
+    data[0,3].each_with_index do |atom,i|
+      coords[i] = atom.xyz
+      na_coords[i] = NArray.to_na(coords[i].to_a)
+    end
+
+    dists_to_surface = Bio::PDB::Utils.distance_to_many(coords[which_atom], [xs, ys, zs] )
+
+    data[3] = Bio::PDB::Utils.rad2deg(data[3]) unless opt[:radians]
+    ids = data[0,3].map {|atom| atom.serial }
+    (don, acc) = [data[0], data[2]].map {|at| [at.resName, at.residue.id, at.name] }
+    ids.push(data[1].name)
+    id_part = ids.push(*don).push(*acc)
+    id_part.push(*(data[3,3]))
+    id_part.push(dists_to_surface.min)
+  end
+
+  final_output = base_h_added + output_postfix
+  File.open(final_output, 'w') do |out|
+    out.puts categories.join(opt[:delim])
+    characterized.each do |array|
+      out.puts array.join(opt[:delim])
+    end
+  end
+end
+

data/lib/hydrogen_bondifier/utils.rb

@@ -0,0 +1,39 @@
+require 'narray'
+
+module Bio
+  class PDB
+    module Utils
+
+      module_function
+      # calculates the angle between 2 Narray vecs (in radians)
+      def angle_between_vectors(vec1, vec2)
+        vec1 = NArray.to_na(vec1.to_a) unless vec1.is_a?(NArray)
+        vec2 = NArray.to_na(vec2.to_a) unless vec2.is_a?(NArray)
+        nil_vec = NArray[0.0, 0.0, 0.0]
+        return nil if (vec1 == nil_vec or vec2 == nil_vec)
+        (mag_a, mag_b) = [vec1,vec2].map {|vec| Math::sqrt((vec*vec).sum) }
+        # acos(dotprod / |a||b|)
+        Bio::PDB::Utils.acos( (vec1 * vec2).sum.to_f  /  (mag_a * mag_b) )
+      end
+
+      def angle_from_coords(triplet)
+        a = triplet.last - triplet[1]
+        b = triplet.first - triplet[1]
+        angle_between_vectors(a,b)
+      end
+
+      # other is 3 parallel NArray objects with the x, y and z coordinates
+      # or a triplet like coord
+      def distance_to_many(coord, other)
+        # distance may be another narray or an array of vecs
+        sq_diffs = []
+        (0...(coord.size)).each do |i|
+          pos = coord[i]
+          oth = other[i]
+          sq_diffs << (oth - pos)**2
+        end
+        NMath.sqrt(sq_diffs.inject {|sum, vec| sum + vec  })
+      end
+    end
+  end
+end

data/lib/pymol/connections.rb

@@ -0,0 +1,55 @@
+require 'pymol'
+
+class Pymol
+  module Connections
+    module Script
+      module_function
+
+      def all_connections_script
+        %Q{
+from pymol import cmd
+
+def all_connections(selection):
+  """
+  USAGE
+
+  all_connections selection
+
+  returns lines: "CONNECTION: id - id"
+  """
+  stored.xs = []
+  cmd.iterate(selection, 'stored.xs.append( index )')
+  for i in stored.xs:
+    selName = "neighbor%s" % i
+    ids = cmd.select(selName, ("%s and neighbor id %s" % (selection, i)))
+    base = "CONNECTION: %s - " % i 
+    to_print = base + "%s"
+    print_string = 'print "' + to_print + '" % index'
+    cmd.iterate(selName, print_string )
+
+cmd.extend("all_connections", all_connections)
+}
+      end
+
+      # returns an array of all pairs of atom IDs with no redundancy
+      def all_connections_parser(reply_from_all_connections, flag=/^CONNECTION: /)
+        pairs = reply_from_all_connections.split("\n").select {|v| v =~ flag }.map do |line|
+          line.split(':').last.split(' - ').map {|v| v.to_i }.sort
+        end
+        pairs.uniq
+      end
+
+    end
+
+    module_function
+
+    # returns all connections as pairs of ID's (all uniq)
+    def from_pdb(pdb)
+      reply = Pymol.run(:msg => 'getting all atom connections', :script => Pymol::Connections::Script.all_connections_script) do |pm|
+        pm.cmd "load #{pdb}, mymodel"
+        pm.cmd "all_connections mymodel"
+      end
+      Pymol::Connections::Script.all_connections_parser(reply)
+    end
+  end
+end

data/lib/pymol/hydrogen_bonds.rb

@@ -0,0 +1,157 @@
+require 'pymol'
+require 'pymol/connections'
+
+require 'bio/db/pdb'
+require 'hydrogen_bondifier/utils'
+
+class Pymol
+  EXCLUDE_WATER_FILTER = " &! resn hoh"
+  module HydrogenBonds
+
+    DEFAULT_FIND_PAIRS_OPTS = {:max_dist => 3.2, :max_angle => 60, :exclude_water => true }
+    DEFAULT_H_BOND_OPTS = {
+      :select_donor => "and (elem n,o and (neighbor hydro))",
+      :select_acceptor => "and (elem o or (elem n and not (neighbor hydro)))",
+    }
+
+    module_function
+
+    def pdb_with_hydrogens(pdb_filename, newname=nil)
+      pfile = pdb_filename
+      newname = pfile.chomp(File.extname(pfile)) + "_plus_h.pdb" unless newname
+      Pymol.run(:msg => 'creating pdb with hydrogens') do |pm|
+        pm.cmd "load #{pfile}, mymodel"
+        pm.cmd "h_add"
+        pm.cmd "save #{newname}"
+      end
+      newname
+    end
+
+    # returns [id1, id2, distance] for each atom
+    def find_pairs(file, sel1, sel2, opt={})
+      opt = DEFAULT_FIND_PAIRS_OPTS.merge( opt )
+      exclude_water_command = opt[:exclude_water] ? EXCLUDE_WATER_FILTER : ""
+      hbond_script = Pymol::HydrogenBonds.list_hb_script(sel1, sel2)
+      reply = Pymol.run(:msg => "getting hydrogen bonds", :script => hbond_script) do |pm|
+        pm.cmd "load #{file}, mymodel"
+        pm.cmd "list_hb mymodel#{exclude_water_command}, cutoff=#{opt[:max_dist]}, angle=#{opt[:max_angle]}"
+      end
+      Pymol::HydrogenBonds.list_hb_parser(reply)
+    end
+
+
+    # returns [donor, hydrogen, acceptor, angle, don_to_acc_dist, h_to_acc_dist]
+    # The first three are Bio::PDB::Record::ATOM structs.
+    # respects DEFAULT_FIND_PAIRS_OPTS and DEFAULT_H_BOND_OPTS
+    # expects that hydrogen bonds are already specified in the PDB file
+    # returns an array triplet atom IDs [donor, hydrogen, acceptor]
+    # :connections can be passed in (an array of arrays of all unique pairwise
+    # connections [by ID])
+    def from_pdb(file, opt={})
+      opt = DEFAULT_H_BOND_OPTS.merge(opt)
+
+      pairs = find_pairs(file, opt[:select_donor], opt[:select_acceptor], opt)
+
+      connection_pairs = Pymol::Connections.from_pdb(file)
+      connection_index = Hash.new {|h,k| h[k] = [] }
+      connection_pairs.each do |pair|
+        connection_index[pair.first] << pair.last
+        connection_index[pair.last] << pair.first
+      end
+
+      # make an index of the atoms
+      pdb = Bio::PDB.new(IO.read(file)) 
+      pdb.extend(Bio::PDB::AtomFinder)
+      atom_index = []
+      pdb.each_atom do |atom|
+        atom_index[atom.serial] = atom
+      end
+
+      max_angle = opt[:max_angle] || DEFAULT_FIND_PAIRS_OPTS[:max_angle]
+      cutoff_in_degress = max_angle
+
+      hbonds = []
+      puts "calculating angles and distances" if $VERBOSE
+      pairs.each do |don_id, acc_id, don_to_acc_dist|
+        donor = atom_index[don_id]
+        acceptor = atom_index[acc_id]  
+        next if (acceptor.element == 'H' or donor.element == 'H') # check for sloppy queries
+        acceptor_xyz = acceptor.xyz
+        donor_xyz = donor.xyz
+        connection_index[don_id].each do |id|
+          hydrogen = atom_index[id]
+          next if hydrogen.element != 'H'
+
+          #puts "ACCEPT ID: "
+          #puts acc_id
+          #p acceptor_xyz
+          #puts "HYDRO ID: "
+          #p id
+          #p hydrogen.xyz
+
+          angle = Bio::PDB::Utils.angle_from_coords([donor_xyz, hydrogen.xyz, acceptor_xyz])
+          h_to_acc_dist = Bio::PDB::Utils.distance(hydrogen.xyz, acceptor_xyz)
+
+          #puts "DISTANCES: "
+          #p don_to_acc_dist
+          #p h_to_acc_dist
+          # abort 'here'
+          
+          # I'm not sure why the angle cutoff is not being respected, but we
+          # can enforce it right here since we want the angles anyway
+          if (180.0 - Bio::PDB::Utils.rad2deg(angle)) <= cutoff_in_degress
+            hbonds << [donor, hydrogen, acceptor, angle, don_to_acc_dist, h_to_acc_dist]
+          end
+        end
+      end
+      hbonds
+    end
+
+    def list_hb_script(select1, select2)
+      %Q{
+# modified by JTP from here:
+# Dr. Robert L. Campbell
+# http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/
+# find_pairs is an undocumented method but mode==1 is hydrogen bond finding
+
+from pymol import cmd
+
+def list_hb(selection,cutoff=3.2,angle=55,hb_list_name='hbonds'):
+  """
+  USAGE
+
+  list_hb selection, [cutoff (default=3.2)], [angle (default=55)], [hb_list_name]
+
+  e.g.
+    list_hb 1abc & c. a &! r. hoh, cutoff=3.2, hb_list_name=abc-hbonds
+  """
+  cutoff=float(cutoff)
+  angle=float(angle)
+  hb = cmd.find_pairs("((byres "+selection+") #{select1})","((byres "+selection+") #{select2})",mode=1,cutoff=cutoff,angle=angle)
+# sort the list for easier reading
+  hb.sort(lambda x,y:(cmp(x[0][1],y[0][1])))
+
+  for pairs in hb:
+    print "PAIR:",
+    for ind in [0,1]:
+      cmd.iterate("%s and index %s" % (pairs[ind][0],pairs[ind][1]), 'print "%s/%3s`%s/%s/%s " % (chain,resn,resi,name,index),')
+    print "%.2f" % cmd.distance(hb_list_name,"%s and index %s" % (pairs[0][0],pairs[0][1]),"%s and index %s" % (pairs[1][0],pairs[1][1]))
+
+cmd.extend("list_hb",list_hb)
+}
+    end
+
+    # takes output of hb_script and returns an array of triplets [id1, id2, distance]
+    def list_hb_parser(pymol_hb_script_reply, flag=/^PAIR: /)
+      # grab each line of output with specified header, then remove the header
+      hbond_lines = pymol_hb_script_reply.split("\n").select {|line| line =~ flag }.map {|line| line.sub(flag,'') }
+
+      ids_and_distances = hbond_lines.map do |line|
+        # A/THR`325/N/2478  A/ALA`323/O/2468  3.05
+        (first, second, dist) = line.split(/\s+/)
+        (id1, id2) = [first, second].map {|v| v.split('/').last.to_i }
+        [id1, id2, dist.to_f]
+      end
+    end
+  end
+end

data/lib/pymol/orientation.rb

@@ -0,0 +1,23 @@
+class Pymol
+  module Orientation
+
+    module_function
+    # http://www.mail-archive.com/pymol-users@lists.sourceforge.net/msg06973.html
+    def orient_to_pdb_coords_script
+      %q{
+def orient_to_pdb_coords():
+  """
+  USAGE
+
+  orient_to_pdb_coords
+  """
+  cmd.reset()
+  cmd.origin(position=[0,0,0])
+  cmd.center("origin")
+  cmd.move('z',-cmd.get_view()[11])
+
+cmd.extend("orient_to_pdb_coords", orient_to_pdb_coords)
+}
+    end
+  end
+end

data/lib/pymol/surface.rb

@@ -0,0 +1,35 @@
+require 'pymol'
+require 'pymol/orientation'
+
+class Pymol
+  module Surface
+    module_function
+    # returns three arrays for the x,y,z coords
+    def obj_file_to_coords(file)
+      coords = []
+      IO.foreach(file) do |line|
+        if line =~ /^v /
+          pieces = line.split(' ')
+          pieces.shift  # remove the 'v'
+          coords << pieces.map {|v| v.to_f }
+        end
+      end
+      coords
+    end
+
+    # returns coordinates
+    # http://pymolwiki.org/index.php/Surface#Exporting_Surface.2FMesh_Coordinates_to_File
+    def from_pdb(file, postfix = "_surface.obj", delete_tmp=true)
+      outfile = file.chomp(File.extname(file)) + postfix
+      Pymol.run(:msg => 'creating surface', :script => Pymol::Orientation.orient_to_pdb_coords_script) do |pm|
+        pm.cmd "load #{file}, mymodel"
+        pm.cmd "orient_to_pdb_coords"
+        pm.cmd "show surface, mymodel"
+        pm.cmd "save #{outfile}"
+      end
+      coords = self.obj_file_to_coords(outfile)
+      File.unlink outfile if delete_tmp
+      coords
+    end
+  end
+end