rubabel 0.1.0 → 0.1.1

data/lib/rubabel/bond.rb

@@ -13,6 +13,15 @@ module Rubabel
   class Bond
     include Enumerable
 
+    class << self
+      def [](atom1, atom2)
+        obbond = OpenBabel::OBBond.new
+        obbond.set_begin(atom1.ob)
+        obbond.set_end(atom2.ob)
+        self.new(obbond)
+      end
+    end
+
     attr_accessor :ob
 
     def initialize(obbond)
@@ -34,6 +43,15 @@ module Rubabel
 
     alias_method :each, :each_atom
 
+    def bond_order
+      @ob.get_bond_order
+    end
+
+    # 1 = single, 2 = double, 5 = aromatic
+    def bond_order=(val=1)
+      @ob.set_bond_order(val)
+    end
+
     # returns an array of Rubabel::Atoms
     def atoms
       [@ob.get_begin_atom.upcast, @ob.get_end_atom.upcast]

data/lib/rubabel/molecule.rb

@@ -2,6 +2,7 @@ require 'openbabel'
 require 'rubabel'
 require 'rubabel/atom'
 require 'rubabel/bond'
+require 'rubabel/molecule/fragmentable'
 
 class OpenBabel::OBMol
   def upcast
@@ -9,25 +10,63 @@ class OpenBabel::OBMol
   end
 end
 
+class OpenBabelUnableToSetupForceFieldError < RuntimeError
+end
+
 module Rubabel
-  # yet to implement: 
+    # yet to implement: 
   class Molecule
     include Enumerable
 
+    DEFAULT_FINGERPRINT = "FP2"
+    DEFAULT_OUT_TYPE = :can
+    DEFAULT_IN_TYPE = :smi
+
     # the OpenBabel::OBmol object
     attr_accessor :ob
 
+    # the OpenBabel::OBConversion object
+    attr_accessor :obconv
+
     class << self
+
+      def tanimoto(mol1, mol2, type=DEFAULT_FINGERPRINT)
+        OpenBabel::OBFingerprint.tanimoto(mol1.ob_fingerprint(type), mol2.ob_fingerprint(type))
+      end
+
       def from_file(file, type=nil)
-        Rubabel.read_file(file, type)
+        Rubabel.molecule_from_file(file, type)
       end
 
-      def from_string(string, type=:smi)
-        Rubabel.read_string(string, type)
+      def from_string(string, type=DEFAULT_IN_TYPE)
+        Rubabel.molecule_from_string(string, type)
       end
     end
 
-    DEFAULT_OUT_TYPE = :can
+
+    # attributes
+    def title() @ob.get_title end
+    def title=(val) @ob.set_title(val) end
+
+    def charge() @ob.get_total_charge end
+    def charge=(v) @ob.set_total_charge(v) end
+
+    def spin() @ob.get_total_spin_multiplicity end
+
+    def mol_wt() @ob.get_mol_wt end
+    alias_method :avg_mass, :mol_wt
+
+    def exact_mass() @ob.get_exact_mass end
+
+    # returns the exact_mass corrected for charge gain/loss
+    def mass
+      @ob.get_exact_mass - (@ob.get_total_charge * Rubabel::MASS_E)
+    end
+
+    # returns a string representation of the molecular formula.  Not sensitive
+    # to add_h!
+    def formula() @ob.get_formula end
+
 
     def initialize(obmol, obconv=nil)
       @obconv = obconv
@@ -64,73 +103,78 @@ module Rubabel
       smarts_indices(smarts_or_string).size > 0
     end
 
-    def charge
-      @ob.get_total_charge
-    end
-
-    def charge=(v)
-      @ob.set_total_charge(v)
-    end
-
-    def spin
-      @ob.get_total_spin_multiplicity
-    end
-
     # returns an array of OpenBabel::OBRing objects.
     def ob_sssr
       @ob.get_sssr.to_a
     end
 
-    def exact_mass
-      @ob.get_exact_mass
-    end
-
-    def mol_wt
-      @ob.get_mol_wt
-    end
-
-    alias_method :avg_mass, :mol_wt
-
-    def exact_mass
-      @ob.get_exact_mass
-    end
-
     #def conformers
       # Currently returns an object of type
       # SWIG::TYPE_p_std__vectorT_double_p_std__allocatorT_double_p_t_t
       #vec = @ob.get_conformers
     #end
+    
+    # are there hydrogens added yet
+    def hydrogens_added?
+      @ob.has_hydrogens_added
+    end
+    alias_method :h_added?, :hydrogens_added?
+
+    # returns self.  Corrects for ph if ph is not nil.  NOTE: the reversal of
+    # arguments from the OpenBabel api.
+    def add_h!(ph=nil, polaronly=false)
+      if ph.nil?
+        @ob.add_hydrogens(polaronly)
+      else
+        @ob.add_hydrogens(polaronly, true, ph)
+      end
+      self
+    end
 
-    def add_h!
-      @ob.add_hydrogens
+    # returns self.  If ph is nil, then #neutral! is called
+    def correct_for_ph!(ph=7.4)
+      ph.nil? ? neutral! : @ob.correct_for_ph(ph)
+      self
     end
-    #alias_method :add_h!, :add_hydrogens!
 
-    # creates a new molecule (currently writes to smiles and uses babel
-    # commandline to get hydrogens at a given pH; this is because no pH model
-    # in ruby bindings currently).
-    def add_h_at_ph(ph=7.4)
-      # write the file with the molecule
-      self.write_file("tmp.smi")
-      system "#{Rubabel::CMD[:babel]} -i smi tmp.smi -p #{ph} -o can tmp.can"
-      Molecule.from_file("tmp.can")
+    # simple method to coerce the molecule into a neutral charge state.
+    # It does this by removing any charge from each atom and then removing the
+    # hydrogens (which will then can be added back by the user and will be
+    # added back with proper valence).  If the molecule had hydrogens added it
+    # will return the molecule with hydrogens added
+    # returns self.
+    def neutral!
+      had_hydrogens = h_added?
+      atoms.each {|atom| atom.charge = 0 if (atom.charge != 0) }
+      remove_h!
+      add_h! if had_hydrogens 
+      self
     end
-    #alias_method :add_h!, :add_hydrogens!
 
+    # adds hydrogens 
+    #def add_h_at_ph!(ph=7.4)
+    #  # creates a new molecule (currently writes to smiles and uses babel
+    #  # commandline to get hydrogens at a given pH; this is because no pH model
+    #  # in ruby bindings currently).
+#
+#      ## write the file with the molecule
+#      #self.write_file("tmp.smi")
+#      #system "#{Rubabel::CMD[:babel]} -i smi tmp.smi -p #{ph} -o can tmp.can"
+#      #Molecule.from_file("tmp.can")
+#    end
+#    #alias_method :add_h!, :add_hydrogens!
+
+    # returns self
     def remove_h!
       @ob.delete_hydrogens
+      self
     end
 
+    # calls separate on the OBMol object
     def separate!
       @ob.separate
     end
 
-    # returns a string representation of the molecular formula.  Not sensitive
-    # to add_h!
-    def formula
-      @ob.get_formula
-    end
-
     # returns just the smiles string :smi (not the id)
     def smiles
       to_s(:smi)
@@ -173,6 +217,14 @@ module Rubabel
       self
     end
 
+    # creates a deep copy of the molecule (even the atoms are duplicated)
+    def initialize_copy(source)
+      super
+      @ob = OpenBabel::OBMol.new(source.ob)
+      @obconv = OpenBabel::OBConversion.new(source.obconv)
+      self
+    end
+
     # returns the array of bonds.  Consider using #each_bond
     def bonds
       each_bond.map.to_a
@@ -198,20 +250,57 @@ module Rubabel
     #def descs
     #end
 
-    # TODO: implement
-    #def fingerprint(type='FP2')
-    #end
-    #alias_method :calc_fp, :fingerprint
+    def tanimoto(other, type=DEFAULT_FINGERPRINT)
+      Rubabel::Molecule.tanimoto(self, other, type)
+    end
 
-    def split(*bonds)
+    # returns a  std::vector<unsigned int> that can be passed directly into
+    # the OBFingerprint.tanimoto method
+    def ob_fingerprint(type=DEFAULT_FINGERPRINT)
+      fprinter = OpenBabel::OBFingerprint.find_fingerprint(type) || raise(ArgumentError, "fingerprint type not found")
+      fp = OpenBabel::VectorUnsignedInt.new
+      fprinter.get_fingerprint(@ob, fp) || raise("failed to get fingerprint for #{mol}")
+      fp
+    end
+
+    # obj is an atom or bond
+    def delete(obj)
+      case obj
+      when Rubabel::Bond
+        delete_bond(obj)
+      when Rubabel::Atom
+        delete_atom(obj)
+      else 
+        raise(ArgumentError, "don't know how to delete objects of type: #{obj.class}")
+      end
+    end
+
+    def delete_bond(bond)
+      @ob.delete_bond(bond.ob)
+    end
+
+    def delete_atom(atom)
+      @ob.delete_atom(atom.ob)
+    end
+
+    # yields self after deleting the specified bonds.  When the block is
+    # closed the bonds are restored.  Returns whatever is returned from the
+    # block.
+    def delete_and_restore_bonds(*bonds, &block)
       bonds.each do |bond|
         unless @ob.delete_bond(bond.ob, false)
           raise "#{bond.inspect} not deleted!" 
         end
       end
-      frags = @ob.separate.map(&:upcast)
+      reply = block.call(self)
       bonds.each {|bond| @ob.add_bond(bond.ob) }
-      frags
+      reply
+    end
+
+    def split(*bonds)
+      delete_and_restore_bonds(*bonds) do |mol|
+        mol.ob.separate.map(&:upcast)
+      end
     end
 
     alias_method :separate, :split
@@ -229,6 +318,11 @@ module Rubabel
       end
     end
 
+    # returns a Rubabel::MoleculeData hash
+    def data
+      Rubabel::MoleculeData.new(@ob)
+    end
+
     # sensitive to add_h!
     def num_atoms() @ob.num_atoms  end
     def num_bonds() @ob.num_bonds  end
@@ -247,15 +341,49 @@ module Rubabel
       end
     end
 
+    # adds hydrogens if necessary.  Performs only steepest descent
+    # optimization (no rotors optimized)
+    # returns self
+    def local_optimize!(forcefield=DEFAULT_FORCEFIELD, steps=500)
+      add_h! unless hydrogens_added?
+      if dim == 3
+        ff = Rubabel.force_field(forcefield.to_s)
+        ff.setup(@ob) || raise(OpenBabelUnableToSetupForceFieldError)
+        ff.steepest_descent(steps)  # is the default termination count 1.0e-4 (used in obgen?)
+        ff.update_coordinates(@ob)
+      else
+        make_3d!(forcefield, steps) 
+      end
+      self
+    end
+
+    #def global_optimize!(forcefield=DEFAULT_FORCEFIELD, steps=1000)
+    #  if dim != 3
+    #    # don't bother optimizing yet (steps=nil)
+    #    make_3d!(DEFAULT_FORCEFIELD, nil)
+    #  end
+    #end
+
+    # does a bit of basic local optimization unless steps is set to nil
+    # returns self
+    def make_3d!(forcefield=DEFAULT_FORCEFIELD, steps=50)
+      BUILDER.build(@ob)
+      @ob.add_hydrogens(false, true) unless hydrogens_added?
+      local_optimize!(forcefield, steps) if steps
+      self
+    end
+    alias_method :make3d!, :make_3d!
+
     def write_string(type=DEFAULT_OUT_TYPE)
       @obconv ||= OpenBabel::OBConversion.new
       @obconv.set_out_format(type.to_s)
       @obconv.write_string(@ob)
     end
 
-    # writes to the file based on the extension
-    def write_file(filename)
-      type = Rubabel.filetype(filename)
+    # writes to the file based on the extension given.  If type is given
+    # explicitly, then it is used.
+    def write_file(filename, type=nil)
+      type ||= Rubabel.filetype(filename)
       File.write(filename, write_string(type))
     end
 

data/lib/rubabel/molecule/fragmentable.rb

@@ -0,0 +1,209 @@
+
+module Rubabel
+  class Molecule
+    module Fragmentable
+      RULES = [:co]
+      #ADDUCTS = [:lioh, :nh4cl, :nh4oh]
+
+      DEFAULT_OPTIONS = {
+        rules: RULES,
+        #adduct: nil,
+        ph: 7.4,
+        # return only the set of unique fragments
+        uniq: false, 
+      }
+
+      # molecules and fragments should all have hydrogens added (add_h!)
+      # before calling this method
+      # 
+      # For instance, water loss with double bond formation is not allowable
+      # for NCC(O)CC => CCC=C[NH2+], presumably because of the lone pair and
+      # double bond resonance.
+      #     
+      def allowable_fragmentation?(frags)
+        self.num_atoms == frags.map(&:num_atoms).reduce(:+)
+      end
+
+      # will turn bond into a double bond, yield the changed molecule, then
+      # return the bond to the original state when the block is closed
+      # returns whatever the block returned
+      def feint_double_bond(bond, &block)
+        orig = bond.bond_order
+        bond.bond_order = 2
+        reply = block.call(self)
+        bond.bond_order = orig
+        reply
+      end
+
+      # to ensure proper fragmentation, will add_h!(ph) first at the given ph
+      # an empty array is returned if there are no fragments generated.
+      def fragment(opts={})
+        opts = DEFAULT_OPTIONS.merge(opts)
+
+        had_hydrogens = self.h_added?
+
+        self.correct_for_ph!(opts[:ph])
+        self.remove_h!
+
+        rules = opts[:rules]
+        fragments = []
+        self.each_match("CO").each do |_atoms|
+          (carbon, oxygen) = _atoms
+          carbon_nbrs = carbon.atoms.reject {|atom| atom == oxygen }
+          c3_nbrs = carbon_nbrs.select {|atm| atm.type == 'C3' }
+          c2_nbrs = carbon_nbrs.select {|atm| atm.type == 'C2' }
+          num_oxygen_bonds = oxygen.bonds.size
+          # pulling this out here causes it to work incorrectly internally
+          # (not sure why)
+          #co_bond = carbon.get_bond(oxygen)
+
+          case num_oxygen_bonds
+          when 1  # an alcohol
+            # water loss
+            if (c3_nbrs.size > 0 || c2_nbrs.size > 0) && !carbon.carboxyl_carbon?
+              if rules.include?(:h2oloss)
+                frag_sets = (c2_nbrs + c3_nbrs).map do |dbl_bondable_atom|
+                  frags = feint_double_bond(dbl_bondable_atom.get_bond(carbon)) do |_mol|
+                    # TODO: check accuracy before completely splitting for efficiency
+                    frags = _mol.split(carbon.get_bond(oxygen))
+                    frags.map(&:add_h!)
+                  end
+                end
+
+                self.add_h!
+                frag_sets.select! do |_frags| 
+                  self.allowable_fragmentation?(_frags)
+                end
+                fragments.push *frag_sets
+              end
+              if rules.include?(:co)
+                # alcohol becomes a ketone and one R group is released
+                frag_sets = c3_nbrs.map do |neighbor_atom|
+                  frags = feint_double_bond(carbon.get_bond(oxygen)) do |_mol|
+                    frags = _mol.split(carbon.get_bond(neighbor_atom))
+                    frags.map(&:add_h!)
+                  end
+                end
+
+                self.add_h!
+                frag_sets.select! do |_frags| 
+                  self.allowable_fragmentation?(_frags)
+                end
+                fragments.push *frag_sets
+              end
+
+              if rules.include?(:co) && (num_oxygen_bonds == 2)
+                if oxygen
+
+
+                  # alcohol becomes a ketone and one R group is released
+                  frag_sets = c3_nbrs.map do |neighbor_atom|
+                    frags = feint_double_bond(carbon.get_bond(oxygen)) do |_mol|
+                      frags = _mol.split(carbon.get_bond(neighbor_atom))
+                      frags.map(&:add_h!)
+                    end
+                  end
+
+                  self.add_h!
+                  frag_sets.select! do |_frags| 
+                    self.allowable_fragmentation?(_frags)
+                  end
+                  fragments.push *frag_sets
+                end
+
+              end
+            end
+            # oxygen bonded to something else (per-oxide??)
+            # also could be ether situation...
+          when 2  
+            raise NotImplementedError
+          end
+        end
+        unless had_hydrogens
+          fragments.each {|set| set.each(&:remove_h!) }
+          self.remove_h!
+        end
+        fragments
+      end
+
+    end
+    include Fragmentable
+  end
+end
+
+
+  #          co_bond = carbon.get_bond(oxygen)
+  #            left_to_c_bond = carbon.get_bond(left)
+  #            right_to_c_bond = carbon.get_bond(right)
+  #
+  #            co_bond.bond_order = 2
+  #
+  #            [left_to_c_bond, right_to_c_bond].flat_map do |other_to_c_bond|
+  #              mol.ob.delete_bond(other_to_c_bond.ob, false)
+  #              pieces = mol.ob.separate.map(&:upcast)
+  #              mol.ob.add_bond(other_to_c_bond.ob)
+  #              pieces
+  #            end
+
+
+=begin
+
+        # duplicate the molecule so we can do what we like with it
+        mol = self.dup
+
+        has_hydrogens_added = h_added?
+        mol.remove_h! if has_hydrogens_added
+
+        mol.correct_for_ph!(opts[:ph])
+
+        rules = opts[:rules]
+        fragments = []
+        if rules.include?(:co)
+          mol.each_match("C(O)").flat_map do |_atoms|
+            carbon = _atoms.first
+            non_oxygen = carbon.each_bond.reject {|bond| bond.include?(_atoms.last) }
+            non_oxygen.each {|bond| p mol.split(bond) }
+
+            fragments.push *non_oxygen.flat_map {|bond| mol.split(bond) }
+          end
+        end
+        p fragments
+        abort 'here'
+        fragments.each(&:add_h!) if has_hydrogens_added
+        fragments
+      end
+    end
+
+=end
+
+
+  #            [[left_to_c_bond, left], [right_to_c_bond, right]].flat_map do |other_to_carbony_c, other|
+  #              puts "INSIDE!!!"
+  #              pieces = mol.split(other_to_carbony_c)
+  #              c_in_pieces = nil
+  #              oxy_in_pieces = nil
+  #              other_in_pieces = nil
+  #              pieces.each do |piece| 
+  #                piece.each_atom do |atom| 
+  #                  p piece
+  #                  p [atom.id, other.id]
+  #                  other_in_pieces = atom if atom.id == other.id
+  #                  c_in_pieces = atom if atom.id == carbon.id 
+  #                  oxy_in_pieces = atom if atom.id == oxygen.id 
+  #                  break if c_in_pieces && oxy_in_pieces
+  #                end
+  #                break if c_in_pieces && oxy_in_pieces
+  #              end
+  #              oxygen_bond = c_in_pieces.get_bond(oxy_in_pieces)
+  #              oxygen_bond.bond_order = 2
+  #
+  #              puts "EXAMINE:other"
+  #              p other_in_pieces.ob
+  #              p other_in_pieces.mol.csmiles
+  #              other_mol = other_in_pieces.mol
+  #              ob_atom = other_mol.ob.new_atom
+  #              ob_atom.set_atomic_num 1
+  #              newbond = OpenBabel::OBBond.new 
+  #              ob_atom
+  #
+