wwood-bioruby 1.2.11

data/lib/bio/db/pdb.rb

@@ -0,0 +1,29 @@
+#
+# = bio/db/pdb.rb - PDB database classes
+#
+# Copyright::	Copyright (C) 2004
+# 		GOTO Naohisa <ngoto@gen-info.osaka-u.ac.jp>
+# License::	The Ruby License
+#
+# $Id: pdb.rb,v 1.8 2007/04/05 23:35:40 trevor Exp $
+#
+
+require 'bio/db'
+
+# definition of the PDB class
+module Bio
+  class PDB #< DB
+
+    autoload :ChemicalComponent, 'bio/db/pdb/chemicalcomponent'
+
+  end #class PDB
+end #module Bio
+
+# require other files under pdb directory
+require 'bio/db/pdb/utils'
+require 'bio/db/pdb/atom'
+require 'bio/db/pdb/residue'
+require 'bio/db/pdb/chain'
+require 'bio/db/pdb/model'
+require 'bio/db/pdb/pdb'
+

data/lib/bio/db/pdb/atom.rb

@@ -0,0 +1,77 @@
+#
+# = bio/db/pdb/atom.rb - Coordinate class for PDB
+#
+# Copyright::  Copyright (C) 2004, 2006
+#              Alex Gutteridge <alexg@ebi.ac.uk>
+#              Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+# $Id: atom.rb,v 1.8 2007/04/05 23:35:41 trevor Exp $
+#
+# = Bio::PDB::Coordinate
+#
+# Coordinate class for PDB.
+#
+# = Compatibility Note
+#
+# From bioruby 0.7.0, the Bio::PDB::Atom class is no longer available.
+# Please use Bio::PDB::Record::ATOM and Bio::PDB::Record::HETATM instead.
+#
+
+require 'matrix'
+require 'bio/db/pdb'
+
+module Bio
+  class PDB
+
+    # Bio::PDB::Coordinate is a class to store a 3D coordinate.
+    # It inherits Vector (in bundled library in Ruby).
+    #
+    class Coordinate < Vector
+      # same as Vector.[x,y,z]
+      def self.[](x,y,z)
+        super
+      end
+
+      # same as Vector.elements
+      def self.elements(array, *a)
+        raise 'Size of given array must be 3' if array.size != 3
+        super
+      end
+
+      # x
+      def x; self[0]; end
+      # y
+      def y; self[1]; end
+      # z
+      def z; self[2]; end
+      # x=(n)
+      def x=(n); self[0]=n; end
+      # y=(n)
+      def y=(n); self[1]=n; end
+      # z=(n)
+      def z=(n); self[2]=n; end
+
+      # Implicit conversion to an array.
+      #
+      # Note that this method would be deprecated in the future.
+      #
+      #--
+      # Definition of 'to_ary' means objects of the class is
+      # implicitly regarded as an array.
+      #++
+      def to_ary; self.to_a; end
+
+      # returns self.
+      def xyz; self; end
+
+      # distance between <em>object2</em>.
+      def distance(object2)
+        Utils::convert_to_xyz(object2)
+        (self - object2).r
+      end
+    end #class Coordinate
+
+  end #class PDB
+end #class Bio
+

data/lib/bio/db/pdb/chain.rb

@@ -0,0 +1,210 @@
+#
+# = bio/db/pdb/chain.rb - chain class for PDB
+#
+# Copyright:: Copyright (C) 2004, 2006
+#             Alex Gutteridge <alexg@ebi.ac.uk>
+#             Naohisa Goto <ng@bioruby.org>
+# License::   The Ruby License
+# 
+# $Id: chain.rb,v 1.10 2008/04/01 10:36:44 ngoto Exp $
+#
+# = Bio::PDB::Chain
+# 
+# Please refer Bio::PDB::Chain.
+#
+
+require 'bio/db/pdb'
+
+module Bio
+
+  class PDB
+
+    # Bio::PDB::Chain is a class to store a chain.
+    #
+    # The object would contain some residues (Bio::PDB::Residue objects)
+    # and some heterogens (Bio::PDB::Heterogen objects).
+    # 
+    class Chain
+      
+      include Utils
+      include AtomFinder
+      include ResidueFinder
+
+      include HetatmFinder
+      include HeterogenFinder
+
+      include Enumerable
+      include Comparable
+
+      # Creates a new chain object.
+      def initialize(id = nil, model = nil)
+        
+        @chain_id  = id
+        
+        @model    = model
+        
+        @residues   = []
+        @residues_hash = {}
+        @heterogens = []
+        @heterogens_hash = {}
+      end
+
+      # Identifier of this chain
+      attr_accessor :chain_id
+      # alias
+      alias id chain_id
+
+      # the model to which this chain belongs.
+      attr_reader :model
+
+      # residues in this chain
+      attr_reader :residues
+
+      # heterogens in this chain
+      attr_reader :heterogens
+      
+      # get the residue by id
+      def get_residue_by_id(key)
+        #@residues.find { |r| r.residue_id == key }
+        @residues_hash[key]
+      end
+
+      # get the residue by id.
+      #
+      # Compatibility Note: Now, you cannot find HETATMS in this method.
+      # To add "LIGAND" to the id is no longer available.
+      # To get heterogens, you must use <code>get_heterogen_by_id</code>.
+      def [](key)
+        get_residue_by_id(key)
+      end
+
+      # get the heterogen (ligand) by id
+      def get_heterogen_by_id(key)
+        #@heterogens.find { |r| r.residue_id == key }
+        @heterogens_hash[key]
+      end
+      
+      #Add a residue to this chain
+      def addResidue(residue)
+        raise "Expecting a Bio::PDB::Residue" unless residue.is_a? Bio::PDB::Residue
+        @residues.push(residue)
+        if @residues_hash[residue.residue_id] then
+          $stderr.puts "Warning: residue_id #{residue.residue_id.inspect} is already used" if $VERBOSE
+        else
+          @residues_hash[residue.residue_id] = residue
+        end
+        self
+      end
+      
+      #Add a heterogen (ligand) to this chain
+      def addLigand(ligand)
+        raise "Expecting a Bio::PDB::Residue" unless ligand.is_a? Bio::PDB::Residue
+        @heterogens.push(ligand)
+        if @heterogens_hash[ligand.residue_id] then
+          $stderr.puts "Warning: heterogen_id (residue_id) #{ligand.residue_id.inspect} is already used" if $VERBOSE
+        else
+          @heterogens_hash[ligand.residue_id] = ligand
+        end
+        self
+      end
+
+      # rehash residues hash
+      def rehash_residues
+        begin
+          residues_bak = @residues
+          residues_hash_bak = @residues_hash
+          @residues = []
+          @residues_hash = {}
+          residues_bak.each do |residue|
+            self.addResidue(residue)
+          end
+        rescue RuntimeError
+          @residues = residues_bak
+          @residues_hash = residues_hash_bak
+          raise
+        end
+        self
+      end
+
+      # rehash heterogens hash
+      def rehash_heterogens
+        begin
+          heterogens_bak = @heterogens
+          heterogens_hash_bak = @heterogens_hash
+          @heterogens = []
+          @heterogens_hash = {}
+          heterogens_bak.each do |heterogen|
+            self.addLigand(heterogen)
+          end
+        rescue RuntimeError
+          @heterogens = heterogens_bak
+          @heterogens_hash = heterogens_hash_bak
+          raise
+        end
+        self
+      end
+
+      # rehash residues hash and heterogens hash
+      def rehash
+        rehash_residues
+        rehash_heterogens
+      end
+
+      # Iterates over each residue
+      def each(&x) #:yields: residue
+        @residues.each(&x)
+      end
+      #Alias to override ResidueFinder#each_residue
+      alias each_residue each
+
+      # Iterates over each hetero-compound
+      def each_heterogen(&x) #:yields: heterogen
+        @heterogens.each(&x)
+      end
+      
+      # Operator aimed to sort based on chain id
+      def <=>(other)
+        return @chain_id <=> other.chain_id
+      end
+      
+      # Stringifies each residue
+      def to_s
+        @residues.join('') + "TER\n" + @heterogens.join('')
+      end
+
+      # returns a string containing human-readable representation
+      # of this object.
+      def inspect
+        "#<#{self.class.to_s} id=#{chain_id.inspect} model.serial=#{(model ? model.serial : nil).inspect} residues.size=#{residues.size} heterogens.size=#{heterogens.size} aaseq=#{aaseq.inspect}>"
+      end
+
+      # gets an amino acid sequence of this chain from ATOM records
+      def aaseq
+        unless defined? @aaseq
+          string = ""
+          last_residue_num = nil
+          @residues.each do |residue|
+            if last_residue_num and 
+                (x = (residue.resSeq.to_i - last_residue_num).abs) > 1 then
+              x.times { string << 'X' }
+            end
+            tlc = residue.resName.capitalize
+            olc = (begin
+                     Bio::AminoAcid.three2one(tlc)
+                   rescue ArgumentError
+                     nil
+                   end || 'X')
+            string << olc
+          end
+          @aaseq = Bio::Sequence::AA.new(string)
+        end
+        @aaseq
+      end
+      # for backward compatibility
+      alias atom_seq aaseq
+      
+    end #class Chain
+
+  end #class PDB
+
+end #module Bio

data/lib/bio/db/pdb/chemicalcomponent.rb

@@ -0,0 +1,224 @@
+#
+# = bio/db/pdb/chemicalcomponent.rb - PDB Chemical Component Dictionary parser
+#
+# Copyright:: Copyright (C) 2006
+#             GOTO Naohisa <ngoto@gen-info.osaka-u.ac.jp>
+# License::   The Ruby License
+#
+# $Id: chemicalcomponent.rb,v 1.3 2007/04/05 23:35:41 trevor Exp $
+#
+# = About Bio::PDB::ChemicalComponent
+#
+# Please refer Bio::PDB::ChemicalComponent.
+#
+# = References
+#
+# * ((<URL:http://deposit.pdb.org/cc_dict_tut.html>))
+# * http://deposit.pdb.org/het_dictionary.txt
+#
+
+require 'bio/db/pdb/pdb'
+
+module Bio
+  class PDB
+
+    # Bio::PDB::ChemicalComponet is a parser for a entry of
+    # the PDB Chemical Component Dictionary.
+    # 
+    # The PDB Chemical Component Dictionary is available in
+    # http://deposit.pdb.org/het_dictionary.txt
+    class ChemicalComponent
+
+      # delimiter for reading via Bio::FlatFile
+      DELIMITER = RS = "\n\n"
+
+      # Single field (normally single line) of a entry
+      class Record < Bio::PDB::Record
+
+        # fetches record name
+        def fetch_record_name(str)
+          str[0..6].strip
+        end
+        private :fetch_record_name
+
+        # fetches record name
+        def self.fetch_record_name(str)
+          str[0..6].strip
+        end
+        private_class_method :fetch_record_name
+
+        # RESIDUE field.
+        # It would be wrong because the definition described in documents
+        # seems ambiguous.
+        RESIDUE =
+          def_rec([ 11, 13, Pdb_LString[3], :hetID ],
+                  [ 16, 20, Pdb_Integer,    :numHetAtoms ]
+                  )
+
+        # CONECT field
+        # It would be wrong because the definition described in documents
+        # seems ambiguous.
+        CONECT =
+          def_rec([ 12, 15, Pdb_Atom,         :name ],
+                  [ 19, 20, Pdb_Integer,      :num ],
+                  [ 21, 24, Pdb_Atom,         :other_atoms ],
+                  [ 26, 29, Pdb_Atom,         :other_atoms ],
+                  [ 31, 34, Pdb_Atom,         :other_atoms ],
+                  [ 36, 39, Pdb_Atom,         :other_atoms ],
+                  [ 41, 44, Pdb_Atom,         :other_atoms ],
+                  [ 46, 49, Pdb_Atom,         :other_atoms ],
+                  [ 51, 54, Pdb_Atom,         :other_atoms ],
+                  [ 56, 59, Pdb_Atom,         :other_atoms ],
+                  [ 61, 64, Pdb_Atom,         :other_atoms ],
+                  [ 66, 69, Pdb_Atom,         :other_atoms ],
+                  [ 71, 74, Pdb_Atom,         :other_atoms ],
+                  [ 76, 79, Pdb_Atom,         :other_atoms ]
+                  )
+
+        # HET field.
+        # It is the same as Bio::PDB::Record::HET.
+        HET    = Bio::PDB::Record::HET
+
+        #--
+        #HETSYN = Bio::PDB::Record::HETSYN
+        #++
+
+        # HETSYN field.
+        # It is very similar to Bio::PDB::Record::HETSYN.
+        HETSYN = 
+            def_rec([  9, 10, Pdb_Continuation, nil ],
+                    [ 12, 14, Pdb_LString(3),   :hetID ],
+                    [ 16, 70, Pdb_String,       :hetSynonyms ]
+                    )
+
+        # HETNAM field.
+        # It is the same as Bio::PDB::Record::HETNAM.
+        HETNAM = Bio::PDB::Record::HETNAM
+
+        # FORMUL field.
+        # It is the same as Bio::PDB::Record::FORMUL.
+        FORMUL = Bio::PDB::Record::FORMUL
+
+        # default definition for unknown fields.
+        Default = Bio::PDB::Record::Default
+
+        # Hash to store allowed definitions.
+        Definition = create_definition_hash
+
+        # END record class.
+        #
+        # Because END is a reserved word of Ruby, it is separately
+        # added to the hash
+        End    = Bio::PDB::Record::End
+        Definition['END'] = End
+
+        # Look up the class in Definition hash
+        def self.get_record_class(str)
+          t = fetch_record_name(str)
+          return Definition[t]
+        end
+      end #class Record
+
+      # Creates a new object.
+      def initialize(str)
+        @data = str.split(/[\r\n]+/)
+        @hash = {}
+
+        #Flag to say whether the current line is part of a continuation
+        cont = false
+        
+        #Goes through each line and replace that line with a PDB::Record
+        @data.collect! do |line|
+          #Go to next if the previous line was contiunation able, and
+          #add_continuation returns true. Line is added by add_continuation
+          next if cont and cont = cont.add_continuation(line)
+
+          #Make the new record
+          f = Record.get_record_class(line).new.initialize_from_string(line)
+          #p f
+          #Set cont
+          cont = f if f.continue?
+          #Set the hash to point to this record either by adding to an
+          #array, or on it's own
+          key = f.record_name
+          if a = @hash[key] then
+            a << f
+          else
+            @hash[key] = [ f ]
+          end
+          f
+        end #each
+        #At the end we need to add the final model
+        @data.compact!
+      end
+
+      # all records in this entry as an array.
+      attr_reader :data
+
+      # all records in this entry as an hash accessed by record names.
+      attr_reader :hash
+
+      # Identifier written in the first line "RESIDUE" record. (e.g. CMP)
+      def entry_id
+        @data[0].hetID
+      end
+
+      # Synonyms for the comical component. Returns an array of strings.
+      def hetsyn
+        unless defined? @hetsyn
+          if r = @hash["HETSYN"]
+            @hetsyn = r[0].hetSynonyms.to_s.split(/\;\s*/)
+          else
+            return []
+          end
+        end
+        @hetsyn
+      end
+      
+      # The name of the chemical component.
+      # Returns a string (or nil, if the entry is something wrong).
+      def hetnam
+        @hash["HETNAM"][0].text
+      end
+
+      # The chemical formula of the chemical component.
+      # Returns a string  (or nil, if the entry is something wrong).
+      def formul
+        @hash["FORMUL"][0].text
+      end
+
+      # Returns an hash of bindings of atoms.
+      # Note that each white spaces are stripped for atom symbols.
+      def conect
+        unless defined? @conect
+          c = {}
+          @hash["CONECT"].each do |e|
+            key = e.name.to_s.strip
+            unless key.empty?
+              val = e.other_atoms.collect { |x| x.strip }
+              #warn "Warning: #{key}: atom name conflict?" if c[key]
+              c[key] = val
+            end
+          end
+          @conect = c
+        end
+        @conect
+      end
+
+      # Gets all records whose record type is _name_.
+      # Returns an array of <code>Bio::PDB::Record::*</code> objects.
+      #
+      # if _name_ is nil, returns hash storing all record data.
+      #
+      # Example:
+      # p pdb.record('CONECT')
+      # p pdb.record['CONECT']
+      #
+      def record(name = nil)
+        name ? @hash[name] : @hash
+      end
+
+    end #class ChemicalComponent
+  end #class PDB
+end #module Bio
+