chemruby 0.9.3

data/lib/chem/db/types/type_sybyl.rb

@@ -0,0 +1,30 @@
+
+module Chem
+
+  module Type
+
+    module SybylType
+
+      def self.detect_file file
+        File.extname(file) == '.mol2'
+      end
+
+      def self.parse file
+        require 'chem/db/sybyl'
+        mol = Chem::Sybyl::SybylMolecule.new file
+      end
+
+      def self.detect_type type
+        type == :sybyl
+      end
+
+      def self.save mol, filename
+        mol.save_as_mdl(filename)
+      end
+
+    end
+  end
+
+  ChemTypeRegistry << Type::SybylType
+
+end

data/lib/chem/db/types/type_xyz.rb

@@ -0,0 +1,26 @@
+
+module Chem
+
+  module Type
+    module XyzType
+
+      def self.detect_file file
+        File.extname(file) == '.xyz'
+      end
+
+      def self.parse file
+        require 'chem/db/xyz.rb'
+        mol = XYZ::XyzMolecule.new
+        mol.open_xyz file
+      end
+
+      def self.detect_type type
+        type == :sdf
+      end
+
+    end
+  end
+
+  ChemTypeRegistry << Type::XyzType
+
+end

data/lib/chem/db/vector.rb

@@ -0,0 +1,128 @@
+
+module Chem
+  module Molecule
+    # Explicitly save molecule as PDF
+    # = Example:
+    #   mol = Chem.open_mol("benzene.mol")
+    #   mol.save_as_pdf("benzene.pdf")
+    #   mol.save("benzene.pdf", :type => :pdf)
+    #   mol.save("benzene.pdf") # File type will automatically detected from file extensions
+    #
+    def save_as_pdf out, params = {}
+      v = PDFWriter.new(self, params)
+      v.save(out)
+    end
+
+  end
+
+  module Atom
+    # position vector for visualization
+    attr_accessor :v_pos
+  end
+
+  module Writer
+
+    def fbox # :nodoc:
+      n = @params[:orig_point]
+      m = [@params[:size][0] + n[0], @params[:size][1] + n[1]]
+      line([m[0], m[1]], [m[0], n[1]], [0, 0, 0])
+      line([m[0], m[1]], [n[0], m[1]], [0, 0, 0])
+      line([m[0], n[1]], [n[0], n[1]], [0, 0, 0])
+      line([n[0], m[1]], [n[0], n[1]], [0, 0, 0])
+    end
+
+    def draw_body # :nodoc:
+      self.fbox() if @params[:fbox]
+      @mol.edges.each do |bond, atom1, atom2|
+        bond.color = [0, 0, 0] unless bond.color
+        a1 = atom1.v_pos.dup
+        a2 = atom2.v_pos.dup
+        diff = a1 - a2
+        len = diff.r
+        # 20 % shorter
+        a1 = a1 - diff * (@default_pointsize / len / 2.5) if atom1.visible
+        a2 = a2 + diff * (@default_pointsize / len / 2.5) if atom2.visible
+
+        vert = Vector[- diff[1], diff[0], 0]
+
+        case bond.stereo
+        when :up
+          fill([a1, a2 + vert * 0.1, a2 - vert * 0.1], bond.color)
+        when :down
+          7.times do |n|
+            line(a1 - diff * (1.0/ 8) * n + vert * 0.015 * n,
+                 a1 - diff * (1.0/ 8) * n - vert * 0.015 * n,
+                 bond.color)
+          end
+        else
+          line(a1, a2, bond.color)
+          if bond.v == 2
+            v = Vector[atom1.x - atom2.x, atom1.y - atom2.y]
+            @mol.adjacent_to(atom1).each do |e, node|
+              next if node == atom2
+              vv = Vector[atom1.x - node.x, atom1.y - node.y]
+              #p a = v.inner_product(vv) / v.r / vv.r
+              #p Math.acos(a)
+            end
+            line(a1 - vert * 0.15 - diff * 0.1,
+                 a2 - vert * 0.15 + diff * 0.1,
+                 bond.color)
+          end
+        end
+      end
+      @mol.nodes.each do |atom|
+        params = {}
+        params[:color] = atom.color if atom.color
+        if atom.visible
+          text(atom.element.to_s, atom.v_pos[0], atom.v_pos[1], params)
+        end
+      end
+    end
+
+    # Constructors for Vector graphics
+    # Accepts several options
+    # :fbox::        true      # black line frame
+    # :upside_down:: true      # turns images upside down
+    # :size::        [10, 20]  # set box size
+    # :pointsize::   18        # set font size
+    def initialize mol, params
+      @mol = mol
+      @params = params
+
+      unless params[:manual] == false
+        mol.nodes.each do |node|
+          node.visible = true unless node.element == :C
+        end
+      end
+
+      @params[:fbox] = true
+      @min = Vector[
+        mol.nodes.min{|atom1, atom2| atom1.x <=> atom2.x}.x,
+        mol.nodes.min{|atom1, atom2| atom1.y <=> atom2.y}.y,
+        mol.nodes.min{|atom1, atom2| atom1.z <=> atom2.z}.z
+      ]
+      @max = Vector[
+        mol.nodes.max{|atom1, atom2| atom1.x <=> atom2.x}.x,
+        mol.nodes.max{|atom1, atom2| atom1.y <=> atom2.y}.y,
+        mol.nodes.max{|atom1, atom2| atom1.z <=> atom2.z}.z
+      ]
+      @size = @max - @min
+      @size = Vector[10.0, 10.0, 0.0] if @size[0] == 0.0 or @size[0] == 0.0
+      x = (@params[:size][0] - @params[:margin][0] * 2) / @size[0]
+      y = (@params[:size][1] - @params[:margin][1] * 2) / @size[1]
+      scale = x < y ? x : y
+      margin = Vector[@params[:margin][0], @params[:margin][1], 0]
+      orig = Vector[* @params[:orig_point] << 0.0]
+      mol.nodes.each do |atom|
+        atom.v_pos = (atom.pos - @min ) * scale + orig + margin
+        if @params[:upside_down]
+          atom.v_pos = Vector[
+            atom.v_pos[0],
+            @params[:size][1] + @params[:margin][1] + @params[:orig_point][1] - atom.v_pos[1],
+            atom.v_pos[2]]
+        end
+      end
+    end
+  end
+end
+

data/lib/chem/db/xyz.rb

@@ -0,0 +1,39 @@
+# Chime XYZ parser
+
+module Chem
+
+  module XYZ
+
+    class XyzAtom
+      include Atom
+      include Chem::Transform::ThreeDimension
+    end
+
+    class XyzMolecule
+
+      include Molecule
+
+      def initialize
+        super
+        @nodes = []
+      end
+
+      def open_xyz filename
+        xyz = open(filename, "r")
+        n_atoms = xyz.readline.to_i
+        title = xyz.readline
+        n_atoms.times do |n|
+          array = xyz.readline.split
+          a = XyzAtom.new
+          a.element, a.x, a.y, a.z = array[0].intern, array[1].to_f, array[2].to_f, array[3].to_f
+          @nodes.push(a)
+        end
+        self
+      end
+
+    end
+
+  end
+
+end
+

data/lib/chem/model.rb

@@ -0,0 +1,119 @@
+#
+# model.rb - Abstract Model for Molecule, Atom and Bond
+#
+#
+# $Id: model.rb 61 2005-10-12 09:17:39Z tanaka $
+#
+
+require 'graph'
+
+module Chem
+
+  # Atom module is top level abstract module for atom in molecule.
+  # It will be mixed-in to other concrete class.
+
+  module Atom
+    # true if visible (for visualization)
+    attr_accessor :visible
+    # [r, g, b]
+    attr_accessor :color
+
+    # atomic symbol (Symbol object)
+    attr_accessor :element
+
+    # x-axis position
+    attr_accessor :x
+
+    # y-axis position
+    attr_accessor :y
+
+    # z-axis position
+    attr_accessor :z
+
+    # charge
+    attr_accessor :charge
+
+    # atomic mass
+    attr_accessor :mass
+
+    # Returns Atomic Number.
+    # If unknown return 100.
+    def atomic_number
+      Number2Element.index(element) ? Number2Element.index(element) : 100
+    end
+
+    # Returns atomic mass
+    def mass
+      return @mass if @mass
+      return Chem::AtomicWeight[element] + @mass_difference if @mass_difference
+      Chem::AtomicWeight[element]
+    end
+
+  end
+
+  module Bond
+    # Returns valency of bond
+    # use bond_type
+    attr_accessor :v
+
+    # Returns Bond Stereo
+    # this method may be overridden by concrete class
+    # :not_stereo:: Not Stereo
+    # :up:: Up
+    # :down:: Down
+    # :cis_trans:: Cis or Trans
+    # :either:: Either
+    def stereo ; :either ; end
+
+    # Returns Bond Type
+    # this method may be overridden by concrete class
+    # :single:: Single bond
+    # :double:: Double bond
+    # :triple:: Triple bond
+    # :aromatic:: Aromatic Bond
+    # :single_or_double:: Single or Double bond
+    # :single_or_aromatic:: Single or Aromatic bond
+    # :double_or_aromatic:: Double or Aromatic bond
+    # :any:: Any bond
+    def bond_type ; :any ; end
+
+    # Returns Topology of bond
+    # this method may be overridden by concrete class
+    # :either:: Either
+    # :ring:: Ring
+    # :chain:: Chain
+    def topology ; :either ; end
+
+    attr_accessor :color # set [r, g, b] for visualization
+
+  end
+
+  module Reaction
+
+  end
+
+  module Molecule
+
+    include Graph
+
+    attr_writer :source # source of molecule
+    attr_writer :name   # name of molecule
+
+    # Returns source of molecule.
+    # default value is ""
+    def source
+      @source ? @source : ""
+    end
+
+    # Returns name of molecule.
+    # default value is self.source
+    def name
+      @name ? @name : self.souce
+    end
+
+  end
+
+end
+
+require 'chem/model/skeleton'
+

data/lib/chem/model/skeleton.rb

@@ -0,0 +1,37 @@
+
+module Chem
+
+  class SkeletonAtom
+    include Atom
+    attr_accessor :x, :y, :z
+  end
+
+  class ReactionSkeleton
+
+    include Reaction
+
+    def initialize compounds
+      @compounds = []
+      @compounds[0] = get_compounds(compounds[0])
+      @compounds[1] = get_compounds(compounds[1])
+    end
+
+    def compounds
+      @compounds
+    end
+
+    private
+    def get_compounds(comp)
+      ret = {}
+      comp.each do |c|
+        if c.kind_of?(Array)
+          ret[c[0]] = c[1]
+        else
+          ret[c] = 1
+        end
+      end
+      ret
+    end
+
+  end
+end

data/lib/chem/utils.rb

@@ -0,0 +1,11 @@
+require 'chem/utils/math'
+require 'chem/utils/transform'
+require 'chem/utils/sssr'
+require 'chem/utils/traverse'
+require 'chem/utils/sub'
+
+require 'chem/utils/prop'
+require 'chem/utils/geometry'
+
+require 'chem/utils/ullmann'
+require 'chem/utils/graph_db'

data/lib/chem/utils/geometry.rb

@@ -0,0 +1,27 @@
+
+module Chem
+
+  module Molecule
+
+    # Automatically assigns 2-dimensional geometry
+    # This method may implicitly called from ChemRuby
+    # if nil is assigned to Atom#x
+    def assign_2d_geometry
+      geometrical_type(nodes[0])
+    end
+
+    private
+    # 
+    def geometrical_type atom
+#       adj = adjacent_to(atom)
+#       case adj.length
+#       when 1
+#       when 2
+#       when 3
+#       when 4
+#       end
+    end
+
+  end
+
+end

data/lib/chem/utils/graph_db.rb

@@ -0,0 +1,146 @@
+
+require 'chem'
+require 'dbm'
+
+module Graph
+
+  class SubGraphDB
+
+    # Create Database object
+    # @idx  : index database for @mat and @typ
+    #         also stores number of nodes.
+    # @mat  : adjacency matrix database
+    # @typ  : node type database
+    # @dbm  : property database
+    def initialize dbname, mode = "w"
+      @dbm = DBM.open("#{dbname}.dbm")
+      @idx = open("#{dbname}.idx", mode)
+      @mat = open("#{dbname}.mat", mode)
+      @typ = open("#{dbname}.typ", mode)
+    end
+
+    def self.open dbname, mode = "r"
+      if mode == "r"
+        SubGraphDB.new(dbname, mode)
+      else
+        self.new(dbname, mode)
+      end
+    end
+
+    def []= key, mol
+      adj = mol.adj_matrix
+      @idx.print [mol.nodes.length, @mat.tell, adj.length].pack("i*")
+      @mat.print adj
+      @typ.print mol.nodes.inject([]){ |ret, node| ret.push(node.atomic_number)}.pack("i*")
+    end
+
+    # Closes database
+    def close
+      @dbm.close
+      @idx.close
+      @mat.close
+      @typ.close
+    end
+
+    # Searches molecule from database
+    # Example:
+    # db = SubGraphDB.open("somewhere/dbname")
+    # db.search(SMILES("CCCC"))
+    def search mol
+      @idx.rewind
+      i = 1
+      until @idx.eof?
+        n_nodes, mat, len_matrix = @idx.read(4 * 3).unpack("i*")
+        m = [0xff].pack("c") * 100
+        open("test.bin", "w").puts m
+
+        matrix = read_mat(mat, len_matrix)
+        #SubGraphDB.show(m, mol.nodes.length, n_nodes)
+        if SubGraphDB.match(matrix, n_nodes, mol.adjacency_list, mol.nodes.length, m)
+          puts "C%05d" % i
+        end
+        i += 1
+      end
+    end
+
+    private
+    def read_mat idx, len_matrix
+      @mat.seek(idx)
+      @mat.read(len_matrix)
+    end
+
+  end
+
+end
+
+__END__
+require 'chem/utils/subgraph/subcomp'
+
+module Chem
+  def self.open_db db_name
+    GraphDB.new(db_name)
+  end
+end
+
+class GraphDB
+
+#   def self.open db_name
+#     self.new(db_name)
+#   end
+
+#   def initialize db_name, mode="w"
+#     if mode == "a"
+#       @idx = File.open("#{db_name}.idx", "r+")
+#     else
+#       @idx = File.open("#{db_name}.idx", mode)
+#     end
+#     @typ = File.open("#{db_name}.typ", mode)
+#     @dat = File.open("#{db_name}.dat", mode)
+#     @num = File.open("#{db_name}.num", mode)
+#     @typ.print("NodeType ISAM")
+#     @dat.print("Adjacency ISAM")
+#   end
+
+  def insert mol
+    n_bytes = mol.nodes.length / ($ARC * 8.0)
+
+#     @typ.flush
+#     @dat.flush
+#     @idx.flush
+
+#     record_num = @idx.tell
+#     @idx.print [@typ.tell, @dat.tell].pack("ii")
+
+#     @typ.print [mol.nodes.length, mol.edges.length].pack("ii")
+#     @dat.print [n_bytes.ceil].pack("i")
+
+#     @typ.print mol.nodes.collect { |node|
+#        Chem::Element2Number[node.element]
+#     }.pack("i*")
+
+#     mol.nodes.each do |k|
+#       atom_type = mol.atoms[k].setup_graph(i)
+#       @typ.print [atom_type].pack("i")
+#     end
+
+
+#     @dat.print [n_bytes.ceil].pack("i")
+#     j = 0
+#     mol.atoms.keys.sort.each do |k|
+#       0.upto(n_bytes.ceil - 1) do |o|
+#         i = 0
+#         mol.atoms[k].set_neighbor
+#         0.upto($ARC * 8 - 1) do |m|
+#           i += mol.atoms[k].neighbor.include?(mol.atoms[m + 8 * $ARC * o + 1]) ? 2**m : 0
+#         end
+#         @dat.print [i].pack("L")
+#       end
+#       j += 1
+#     end
+#     #p mol.adjacency_list
+#     mol.connection.each do |c|
+#       puts "%040b" % c
+#     end
+    #record_num
+  end
+end