chemruby 0.9.3 → 1.1.9

data/lib/chem/utils/fingerprint.rb

@@ -0,0 +1,98 @@
+require 'set'
+
+class Integer
+
+  def to_bit_positions
+    ary = []
+    i   = 0
+    pow = 0
+    while pow <= self
+      pow = 1 << i
+      if((pow & self) != 0)
+        ary << i
+      end
+      i += 1
+    end
+    ary
+  end
+
+end
+
+
+module Chem
+
+  module Atom
+    attr_accessor :rings
+  end
+
+  module Molecule
+
+    def f_dfs node, path, max, &block
+      if not path.length > max
+        yield path
+        self.adjacent_to(node).each do |bond, n|
+          next if n.element == :H
+          if not path.include?(n)
+            path.push(n)
+            f_dfs(n, path, max, &block)
+            path.pop
+          end
+        end
+      end
+    end
+
+#     ELEMNUM = {
+#       :C => 0,
+#       :N => 1,
+#       :O => 2,
+#       :P => 4}
+#     ELEMNUM.default = 32
+
+    ELEMNUM = Element2Number.inject({}) do |ret, (elem, num)|
+      ret[elem] = 1 << num
+      ret
+    end
+    ELEMNUM.default = 32
+
+    # 
+    def fingerprint(max = 3, n_bits = 32)
+
+      find_sssr.each do |rings|
+        len = rings.length
+        rings.each do |atom|
+          (atom.rings ||= []) << len
+        end
+      end
+
+      fp = 0
+      set = Set.new
+
+      nodes.each do |node|
+        f_dfs(node, [node], max) do |path|
+          # Exclude unwanted path
+          key = path.collect{|atom| atom.element.to_s}.join(".")
+          next if set.include?(key)
+
+          set.add(key)
+          set.add(path.reverse.collect{|atom| atom.element.to_s}.join("."))
+          # seed calculation
+          seed = 0
+          path.each_with_index do |atom, idx|
+            seed += (1 << ( 5 * idx)) *
+              ELEMNUM[atom.element] *
+              (atom.rings.nil? ? 1 : (1 << atom.rings.length))
+          end
+          srand(seed)
+          1.times do |n|
+            fp |= 1 << rand(n_bits)
+          end
+        end
+      end
+      fp
+    end
+
+  end
+
+end
+
+

data/lib/chem/utils/geometry.rb

@@ -3,6 +3,14 @@ module Chem
 
   module Molecule
 
+    # Return size of molecule with Array [x, y, z]
+    def box_size
+      size_x = nodes().max{|a1, a2| a1.x <=> a2.x}.x - nodes().min{|a1, a2| a1.x <=> a2.x}.x
+      size_y = nodes().max{|a1, a2| a1.y <=> a2.y}.y - nodes().min{|a1, a2| a1.y <=> a2.y}.y
+      size_z = nodes().max{|a1, a2| a1.z <=> a2.z}.z - nodes().min{|a1, a2| a1.z <=> a2.z}.z
+      [size_x, size_y, size_z]
+    end
+
     # Automatically assigns 2-dimensional geometry
     # This method may implicitly called from ChemRuby
     # if nil is assigned to Atom#x

data/lib/chem/utils/net.rb

@@ -0,0 +1,303 @@
+# Copyright (C) 2005, 2006 KADOWAKI Tadashi <tadakado@gmail.com>
+#                          TANAKA   Nobuya  <nobuya.tanaka@gmail.com>
+#                          APODACA  Richard <r_apodaca@users.sf.net>
+
+require 'net/http'
+require 'net/ftp'
+require 'date'
+require 'rexml/document'
+require 'cgi'
+
+module Chem
+
+  module NetUtils
+
+    def http_get(str)
+      Net::HTTP.get(URI.parse(str))
+    end
+
+  end
+
+  def self.search_net(term, options)
+    case options[:db]
+    when :pubmed
+      Chem::NCBI::ESearch.query(term, options)
+    when :pubchem
+      Chem::NCBI::ESearch.query(term, options)
+    end
+  end
+
+  class NCBI
+    EUtilsURI  = 'http://eutils.ncbi.nlm.nih.gov/entrez/eutils/'
+    PubChemURI = 'http://pubchem.ncbi.nlm.nih.gov/'
+
+    # EInfo
+    module EInfo
+      extend Chem::NetUtils
+
+      EInfoURI = EUtilsURI + 'einfo.fcgi?'
+
+      def self.query(params = {})
+        if params.empty?
+          xml = REXML::Document.new(http_get(EInfoURI))
+          dbs = []
+          xml.elements.each("eInfoResult/DbList/DbName") do |element|
+            dbs << element.text
+          end
+          dbs
+        elsif params[:db]
+          DbInfo.new(REXML::Document.new(http_get(EInfoURI + "db=" + params[:db].to_s)))
+        end
+      end
+
+      class DbInfo
+        attr_reader :db_name, :menu_name, :description, :count, :last_update
+        def initialize(xml)
+          @db_name     = xml.elements["eInfoResult/DbInfo/DbName"].text
+          @menu_name   = xml.elements["eInfoResult/DbInfo/MenuName"].text
+          @description = xml.elements["eInfoResult/DbInfo/Description"].text
+          @count       = xml.elements["eInfoResult/DbInfo/Count"].text
+          @last_update = xml.elements["eInfoResult/DbInfo/LastUpdate"].text
+          @fields = []
+          xml.elements.each("eInfoResult/DbInfo/FieldList/Field") do |element|
+            @fields << {
+              :name         => element.elements["Name"       ].text,
+              :full_name    => element.elements["FullName"   ].text,
+              :description  => element.elements["Description"].text,
+              :term_count   => element.elements["TermCount"  ].text,
+              :is_date      => element.elements["IsDate"     ].text == "Y",
+              :is_numerical => element.elements["IsNumerical"].text == "Y",
+              :single_token => element.elements["SingleToken"].text == "Y",
+              :hierarchy    => element.elements["Hierarchy"  ].text == "Y",
+              :is_hidden    => element.elements["IsHidden"   ].text == "Y",
+            }
+          end
+        end
+      end
+      
+    end # EInfo module
+
+    module ESearch
+      extend Chem::NetUtils
+
+      ESearchURI = EUtilsURI + 'esearch.fcgi?'
+
+      def self.search(params)
+        result = {}
+        uri = ESearchURI + params.collect{|key, value| key.to_s + "=" + CGI.escape(value.to_s)}.join("&")
+        doc = http_get(uri)
+        xml = REXML::Document.new(doc)
+        raise "Error no result" unless xml.elements["eSearchResult/ERROR"].nil?
+
+        result[:count]     = xml.elements["eSearchResult/Count"   ].text.to_i
+        result[:retmax]   = xml.elements["eSearchResult/RetMax"  ].text.to_i
+        result[:retstart] = xml.elements["eSearchResult/RetStart"].text.to_i
+        
+        result[:id_list] = list = []
+        xml.elements.each("eSearchResult/IdList/Id") do |element|
+          list << element.text.to_i
+        end
+        result
+      end
+
+    end
+
+    module PCFetch
+
+      extend Chem::NetUtils
+
+      PCFetchURI = PubChemURI + 'pc_fetch/pc_fetch.cgi?'
+
+      def self.fetch(params)
+        raise "You need to specify :retmode" if params[:retmode].nil?
+
+        uri = PCFetchURI + params.collect{|key, value| key.to_s + "=" + value.to_s}.join("&")
+        doc = http_get(uri)
+        num = 0
+        if m = /pubchem\/\.fetch\/(\d+).sdf/.match(doc)
+          puts 'ftp'
+          num = m[1].to_i
+        elsif m = /reqid=(\d+)/.match(doc)
+          puts 'http'
+          num = m[1].to_i
+        else
+          raise "Cannot retrieve file"
+        end
+
+        params[:localfilename] ||= "%s%d.sdf" % [params[:db], params[:id]]
+
+        begin
+          ftp = Net::FTP.open("ftp.ncbi.nih.gov")
+          ftp.login
+          ftp.gettextfile("pubchem/.fetch/%d.sdf" % num, params[:localfilename])
+        rescue Net::FTPPermError
+          puts "error : num"
+          retry
+        end
+
+      end
+
+    end
+
+    module ESummary
+
+      extend Chem::NetUtils
+      ESummaryURI = EUtilsURI + 'esummary.fcgi?'
+
+      def self.get(params)
+        uri = ESummaryURI + params.collect{|key, value| key.to_s + "=" + value.to_s}.join("&")
+        http_get(uri)
+      end
+
+      def self.get_parsed(params)
+        tree = {}
+        xml = REXML::Document.new(get(params))
+        xml.elements.each("eSummaryResult/DocSum/Item") do |element|
+          tree[element.attributes["Name"]] =
+            case element.attributes["Type"]
+            when "String"
+              element.text
+            when "Integer"
+              element.text.to_i
+            when "Date"
+              element.text
+            when "List"
+              ary = []
+              element.elements.each("Item"){|el|
+              ary << case el.attributes["Type"]
+                     when "String"
+                       el.text
+                     when "Integer"
+                       el.text.to_i
+                     else
+                       ""
+                     end
+            }
+              ary
+            end
+        end
+        tree
+      end
+    end
+
+    # obsolete
+    class EFetch
+
+      include Chem::NetUtils
+
+      EFetchURI  = EUtilsURI + 'efetch.fcgi' + '?'
+
+      def initialize(query_key, web_env)
+        uri = [PCFetchURI]
+        uri << 'db=pccompound'
+        uri << '&WebEnv=' + web_env
+        uri << '&query_key=' + query_key
+        uri << '&retmode=sdf'
+        uri << '&compression=none'
+        #"retmode=xml&"
+        #uri = EFetchURI + "&db=pccompound&retmode=xml&WebEnv=" + web_env + "&query_key=" + query_key + "&tool=oscar3&email=nobuya.tanaka%40gmail.com"
+        p uri.join
+        doc = http_get(uri.join)
+        if m = /bookmarking this page or by going to<\/p><p><a href=\"([^"]+)/.match(doc)
+          sleep 1
+          p m[1]
+          d = http_get(m[1])
+          m = /"ftp:\/\/([^"]+)/.match(d)
+          p m[1]
+          require 'net/ftp'
+          begin
+            sleep 0.5
+            ftp = Net::FTP.open("ftp.ncbi.nih.gov")
+            ftp.login
+            ftp.gettextfile("pubchem/.fetch/606874731181068179.sdf")
+          rescue Net::FTPPermError
+            sleep 1
+            puts 'OK'
+          end
+            
+        end
+      end
+
+      def self.fetch_all(query_key, web_env)
+        new(query_key, web_env)
+      end
+
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  # search PubChem compounds using InChI
+  query = {
+    :db   => :pccompound,
+    :term => '"InChI=1/C9H8O4/c1-6(10)13-8-5-3-2-4-7(8)9(11)12/h2-5H,1H3,(H,11,12)/f/h11H"'
+  }
+  
+  p Chem::NCBI::ESearch.search(query)
+
+  # search PubChem substance with term
+
+  query = {
+    :db   => "pcsubstance",
+    :term => 'benzene'
+  }
+
+  p Chem::NCBI::ESearch.search(query)
+
+  # search PubChem substance with complete synonyms
+
+  query = {
+    :db    => "pcsubstance",
+    :term  => 'benzene',
+    :field => 'CSYN',
+  }
+
+  p Chem::NCBI::ESearch.search(query)
+
+  # search PubMed
+  query = {
+    :db   => "pubmed",
+    :term => "asthma[mh]+OR+hay+fever[mh]",
+  }
+
+  p query
+  p Chem::NCBI::ESearch.search(query)
+
+  # Retrieving more entries
+
+  query = {
+    :db         => "pubmed",
+    :term       => "cancer",
+    :reldate    => 60,
+    :datetype   => "edat",
+    :retmax     => 100,
+    :retstart   => 300,
+  }
+
+  p Chem::NCBI::ESearch.search(query)
+
+  # Retrieving Eutils database information
+  p  Chem::NCBI::EInfo.query
+
+
+  # Rerieving information about PubChem Compounds
+
+  pp Chem::NCBI::EInfo.query(:db => :pccompound)
+
+  # Retrieving pccompound using PC_Fetch
+  # Not recommended
+  # It seems that EFetch does not accept db=pccompound
+  # PCFetch could be alternatives for EFetch.
+
+  100.upto(110) do |n|
+    puts n
+    Chem::NCBI::PCFetch::fetch({:db => :pccompound, :id => n, :retmode => :sdf})
+  end
+
+  # Retrieving parsed summary for entries
+  # CID:100 
+  p Chem::NCBI::ESummary::get_parsed({:db => :pccompound, :id => 100})
+
+end
+

data/lib/chem/utils/once.rb

@@ -0,0 +1,28 @@
+module Once
+
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def once(*ids) # :nodoc:
+      for id in ids
+	module_eval <<-"end;", __FILE__, __LINE__
+        alias_method :__#{id.to_i}__, :#{id.to_s}
+        private :__#{id.to_i}__
+        def #{id.to_s}(*args, &block)
+          if defined? @__#{id.to_i}__
+            @__#{id.to_i}__
+          elsif ! self.frozen?
+            @__#{id.to_i}__ ||= __#{id.to_i}__(*args, &block)
+          else
+            __#{id.to_i}__(*args, &block)
+          end
+        end
+      end;
+      end
+    end
+  end
+
+end

data/lib/chem/utils/openbabel.rb

@@ -0,0 +1,204 @@
+# Copyright (C) 2006 Richard L. Apodaca
+#                    Nobuya     Tanaka
+
+require 'chem'
+
+module Chem
+
+  module Atom
+    attr_accessor :ob_atom
+  end
+
+  module Molecule
+
+    attr_reader :ob_mol
+    def ob_save_as(path, filetype)
+      use_open_babel if @ob_mol.nil?
+      conv = ::OpenBabel::OBConversion.new
+      conv.set_out_format(filetype.to_s)
+      conv.write_file(@ob_mol, path)
+    end
+
+    def ob_export_as(filetype)
+      use_open_babel if @ob_mol.nil?
+      conv = ::OpenBabel::OBConversion.new
+      conv.set_out_format(filetype.to_s)
+      conv.write_string(@ob_mol)
+    end
+
+    def to_inchi
+      use_open_babel
+      ob_export_as("inchi").chop
+    end
+
+    # set OpenBabel OBMol object to instance variable @ob_mol
+    def use_open_babel
+      begin
+        require 'openbabel'
+      rescue Exception
+        require 'OpenBabel'
+      end
+      @ob_mol = ::OpenBabel::OBMol.new
+      nodes.each do |node|
+        atom = @ob_mol.new_atom
+        atom.set_atomic_num(Element2Number[node.element])
+        atom.set_vector(node.x.to_f, node.y.to_f, node.z.to_f)
+        node.ob_atom = atom
+      end
+      edges.each do |bond, atom1, atom2|
+        @ob_mol.add_bond(
+                         atom1.ob_atom.get_idx,
+                         atom2.ob_atom.get_idx,
+                         bond.v.to_i
+                         )
+      end
+    end
+
+  end
+
+  module OpenBabel
+
+    def self.parse_smiles(smiles)
+
+      require 'openbabel'
+
+      converter = ::OpenBabel::OBConversion.new
+      converter.set_in_format("smi")
+      mol = ::OpenBabel::OBMol.new
+      converter.read_string(mol, smiles)
+      OBMolecule.new(mol)
+    end
+
+    def self.load_sdf(path)
+      require 'openbabel'
+
+      conv = ::OpenBabel::OBConversion.new
+      conv.set_in_format("sdf")
+      mol  = ::OpenBabel::OBMol.new
+      cond = conv.read_file(mol, path)
+      mols = [OBMolecule.new(mol)]
+      while cond
+        mol  = ::OpenBabel::OBMol.new
+        cond = conv.read(mol)
+        mols << OBMolecule.new(mol) if cond
+      end
+      mols
+    end
+
+    class OBSmarts
+
+      def initialize(smarts)
+        require 'openbabel'
+        @pat = ::OpenBabel::OBSmartsPattern.new
+        @pat.init(smarts)
+        @pat
+      end
+
+      def match(mol)
+        mol.use_open_babel if mol.ob_mol.nil?
+        @pat.match(mol.ob_mol)
+      end
+
+      def get_umap_list
+        @pat.get_umap_list.collect{|ary| ary.collect{|i| i.to_i}}
+      end
+
+    end
+
+    def self.parse_smarts(smarts)
+      OBSmarts.new(smarts)
+    end
+
+    # load_as(path, filetype)
+    # path     : path to input file
+    # filetype : "alc", "bgf"
+    # see http://openbabel.sourceforge.net/wiki/Babel
+    def self.load_as(path, filetype)
+      conv = ::OpenBabel::OBConversion.new
+      conv.set_in_format(filetype.to_s)
+      mol  = ::OpenBabel::OBMol.new
+      conv.read_file(mol, path)
+      OBMolecule.new(mol)
+    end
+
+    module OBAtom
+      include Atom
+    end
+
+    class OBMolecule
+      include Molecule
+
+      attr_reader :ob_mol
+      attr_reader :nodes
+      def initialize(ob_mol)
+        @ob_mol = ob_mol
+        @nodes = []
+        1.upto(@ob_mol.num_atoms) do |n|
+          atom = @ob_mol.get_atom(n)
+          @nodes << atom.extend(OBAtom)
+        end
+      end
+
+    end
+  end # OpenBabel module
+  
+end
+
+if __FILE__ == $0
+  mol = SMILES("CCC")
+  mol.use_open_babel
+  p mol.num_atoms
+  p mol.num_bonds
+  p mol.get_mol_wt
+  p mol.get_exact_mass
+  # p mol.add_hydrogens # BUS Error !?
+elsif false
+  ob = Chem::OpenBabel.parse_smiles('CC(C)CCCC(C)C1CCC2C1(CCC3C2CC=C4C3(CCC(C4)O)C)C')
+  p ob.get_mol_wt
+  p ob.num_atoms
+  p ob.num_bonds
+  # read
+  # is_last
+
+  atom = ob.new_atom
+
+# creating new molecule
+
+  mol = OBMol.new
+  atom1 = mol.add_atom
+  atom2 = mol.add_atom
+
+  # Atom
+
+  atom1 = mol.get_first_atom
+  atom1 = mol.get_atom(1)
+
+  # Atom setter and getter
+
+  atom1.set_atomic_num(6) # Carbon
+
+  atom1.get_atomic_mass   # Carbon : 12.0107
+
+  atom1.set_aromatic      # aromatic
+  atom1.unset_aromatic    # not aromatic
+  atom1.is_aromatic       # return true or false
+
+  atom1.is_amide_nitrogen # return true or false
+  
+
+  # atom count starts from 1 (not 0)
+  # mol.add_bond(0, 1, 1) fails!
+  mol.add_bond(1, 2, 1)# from, to, bond_order
+  # bond count starts from 0 (not 1)
+
+  bond = mol.get_bond(0)
+  bond.is_double
+  bond.is_single
+  bond.is_amide
+  bond.get_bond_order # bond.get_bo
+
+  # bond length
+
+  bond.get_length
+  bond.set_length# arguments ?
+end