Class: Rubabel::Molecule
- Includes:
- Enumerable, Fragmentable
- Defined in:
- lib/rubabel/molecule/fragmentable.rb,
lib/rubabel/molecule.rb
Defined Under Namespace
Modules: Fragmentable
Constant Summary collapse
- DEFAULT_FINGERPRINT =
"FP2"
- DEFAULT_OUT_TYPE =
:can
- DEFAULT_IN_TYPE =
:smi
Constants included from Fragmentable
Fragmentable::DEFAULT_OPTIONS, Fragmentable::RULES
Instance Attribute Summary collapse
-
#ob ⇒ Object
the OpenBabel::OBmol object.
Class Method Summary collapse
- .from_atoms_and_bonds(atoms = [], bonds = []) ⇒ Object
- .from_file(file, type = nil) ⇒ Object
- .from_string(string, type = DEFAULT_IN_TYPE) ⇒ Object
- .tanimoto(mol1, mol2, type = DEFAULT_FINGERPRINT) ⇒ Object
Instance Method Summary collapse
-
#==(other) ⇒ Object
defined as whether the csmiles strings are identical.
-
#[](*args) ⇒ Object
retrieves the atom by index (accepts everything an array would).
-
#add_atom!(arg = 6, bond_order = 1, attach_to = nil) ⇒ Object
(also: #<<)
returns the atom passed in or that was created.
-
#add_bond!(atom1, atom2, order = 1) ⇒ Object
takes a pair of Rubabel::Atom objects and adds a bond to the molecule returns whether the bond creation was successful.
-
#add_h!(ph = nil, polaronly = false) ⇒ Object
returns self.
-
#add_polar_h! ⇒ Object
only adds polar hydrogens.
-
#associate_atom!(arg) ⇒ Object
arg may be a Fixnum, a Symbol (Elemental symbol that is a Symbol), or a Rubabel::Atom.
-
#atom(id) ⇒ Object
gets the atom by id.
-
#atoms ⇒ Object
returns the array of atoms.
-
#bond(id) ⇒ Object
gets the bond by id.
-
#bonds ⇒ Object
returns the array of bonds.
-
#center! ⇒ Object
centers the molecule (deals with the atomic coordinate systems for 2D or 3D molecules).
- #charge ⇒ Object
- #charge=(v) ⇒ Object
-
#convert_dative_bonds! ⇒ Object
returns self.
-
#correct_for_ph!(ph = 7.4) ⇒ Object
returns self.
-
#csmiles ⇒ Object
returns just the smiles string (not the id).
-
#data ⇒ Object
returns a Rubabel::MoleculeData hash.
-
#delete(obj) ⇒ Object
obj is an atom or bond.
-
#delete_and_restore_bonds(*bonds, &block) ⇒ Object
yields self after deleting the specified bonds.
- #delete_atom(atom) ⇒ Object
-
#delete_bond(*args) ⇒ Object
if given a bond, deletes it (doesn’t garbage collect).
-
#delete_hydrogens! ⇒ Object
(also: #remove_h!, #remove_hydrogens!)
returns self.
- #dim ⇒ Object
-
#do_with_hydrogens(ph = nil, polaronly = false, &block) ⇒ Object
ensures that hydrogens are added before an operation, but returns the molecule to the original hydrogen or no hydrogen state when finished.
- #do_without_hydrogens(ph = nil, polaronly = false, &block) ⇒ Object
-
#each_atom(&block) ⇒ Object
(also: #each)
iterates over the molecule’s Rubabel::Atom objects.
-
#each_bond(&block) ⇒ Object
iterates over the molecule’s Rubabel::Bond objects.
- #each_fragment(&block) ⇒ Object
-
#each_match(smarts_or_string, uniq = true, &block) ⇒ Object
yields atom arrays matching the pattern.
-
#equal?(other) ⇒ Boolean
(also: #eql?)
checks to see if the molecules are the same OBMol object underneath by modifying one and seeing if the other changes.
- #exact_mass ⇒ Object
-
#formula ⇒ Object
returns a string representation of the molecular formula.
-
#graph_diameter ⇒ Object
obconv.add_option(“u”,OpenBabel::OBConversion::OUTOPTIONS) self end.
-
#highlight_substructure!(substructure, color = 'red') ⇒ Object
returns self.
-
#hydrogens_added? ⇒ Boolean
(also: #h_added?)
are there hydrogens added yet.
-
#initialize(obmol = nil) ⇒ Molecule
constructor
A new instance of Molecule.
-
#initialize_copy(source) ⇒ Object
creates a deep copy of the molecule (even the atoms are duplicated).
- #inspect ⇒ Object
-
#kekulize! ⇒ Object
returns self.
-
#local_optimize!(forcefield = DEFAULT_FORCEFIELD, steps = 500) ⇒ Object
adds hydrogens if necessary.
-
#make_3d!(forcefield = DEFAULT_FORCEFIELD, steps = 50) ⇒ Object
(also: #make3d!)
does a bit of basic local optimization unless steps is set to nil returns self.
-
#mass ⇒ Object
returns the exact_mass corrected for charge gain/loss.
-
#matches(smarts_or_string, uniq = true) ⇒ Object
returns an array of matching atom sets.
- #matches?(smarts_or_string) ⇒ Boolean
- #mol_wt ⇒ Object (also: #avg_mass)
-
#neutral! ⇒ Object
simple method to coerce the molecule into a neutral charge state.
-
#new_bond ⇒ Object
creates a new (as yet unspecified) bond associated with the molecule and gives it a unique id.
-
#num_atoms(count_implied_hydrogens = false) ⇒ Object
sensitive to add_h!.
- #num_bonds ⇒ Object
- #num_hvy_atoms ⇒ Object
- #num_residues ⇒ Object
- #num_rotors ⇒ Object
-
#ob_fingerprint(type = DEFAULT_FINGERPRINT) ⇒ Object
returns a std::vector<unsigned int> that can be passed directly into the OBFingerprint.tanimoto method.
-
#ob_sssr ⇒ Object
returns an array of OpenBabel::OBRing objects.
-
#png_transformer(type_s, out_options = {}, &block) ⇒ Object
yields the type of object.
-
#smarts_indices(smarts_or_string, uniq = true) ⇒ Object
returns a list of atom indices matching the patterns (corresponds to the OBSmartsPattern::GetUMapList() method if uniq==true and GetMapList method if uniq==false).
-
#smiles ⇒ Object
returns just the smiles string :smi (not the id).
- #spin ⇒ Object
-
#split(*bonds) ⇒ Object
splits the molecules at the given bonds and returns the fragments.
-
#strip_salts! ⇒ Object
returns self.
-
#swap!(anchor1, to_move1, anchor2, to_move2) ⇒ Object
swaps to_move1 for to_move2 on the respective anchors returns self.
-
#tanimoto(other, type = DEFAULT_FINGERPRINT) ⇒ Object
TODO: implement list of supported descriptors.
-
#title ⇒ Object
attributes.
- #title=(val) ⇒ Object
-
#to_s(type = DEFAULT_OUT_TYPE) ⇒ Object
emits smiles without the trailing tab, newline, or id.
-
#write(filename_or_type = :can, out_options = {}) ⇒ Object
If filename_or_type is a symbol, then it will return a string of that type.
-
#write_file(filename, out_options = {}) ⇒ Object
writes to the file based on the extension given (must be recognized by OpenBabel).
-
#write_string(type = DEFAULT_OUT_TYPE, out_options = {}) ⇒ Object
out_options include any of those defined.
Methods included from Enumerable
Methods included from Fragmentable
#allowable_fragmentation?, #break_with_double_bond, #carbon_oxygen_esteal, #carbonyl_oxygen_dump, #dup_molecule, #fragment
Constructor Details
#initialize(obmol = nil) ⇒ Molecule
Returns a new instance of Molecule.
177 178 179 |
# File 'lib/rubabel/molecule.rb', line 177 def initialize(obmol=nil) @ob = obmol.nil? ? OpenBabel::OBMol.new : obmol end |
Instance Attribute Details
#ob ⇒ Object
the OpenBabel::OBmol object
82 83 84 |
# File 'lib/rubabel/molecule.rb', line 82 def ob @ob end |
Class Method Details
.from_atoms_and_bonds(atoms = [], bonds = []) ⇒ Object
103 104 105 106 107 108 |
# File 'lib/rubabel/molecule.rb', line 103 def from_atoms_and_bonds(atoms=[], bonds=[]) obj = self.new( OpenBabel::OBMol.new ) atoms.each {|atom| obj.add_atom(atom) } bonds.each {|bond| obj.add_bond(bond) } obj end |
.from_file(file, type = nil) ⇒ Object
90 91 92 93 |
# File 'lib/rubabel/molecule.rb', line 90 def from_file(file, type=nil) (obmol, obconv, not_at_end) = Rubabel.read_first_obmol(file, type).first Rubabel::Molecule.new(obmol) end |
.from_string(string, type = DEFAULT_IN_TYPE) ⇒ Object
95 96 97 98 99 100 101 |
# File 'lib/rubabel/molecule.rb', line 95 def from_string(string, type=DEFAULT_IN_TYPE) obmol = OpenBabel::OBMol.new obconv = OpenBabel::OBConversion.new obconv.set_in_format(type.to_s) || raise(ArgumentError, "invalid format #{type}") obconv.read_string(obmol, string) || raise(ArgumentError, "invalid string" ) self.new(obmol) end |
.tanimoto(mol1, mol2, type = DEFAULT_FINGERPRINT) ⇒ Object
86 87 88 |
# File 'lib/rubabel/molecule.rb', line 86 def tanimoto(mol1, mol2, type=DEFAULT_FINGERPRINT) OpenBabel::OBFingerprint.tanimoto(mol1.ob_fingerprint(type), mol2.ob_fingerprint(type)) end |
Instance Method Details
#==(other) ⇒ Object
defined as whether the csmiles strings are identical. This incorporates more information than the FP2 fingerprint, for instance (try changing the charge and see how it does not influence the fingerprint). Obviously, things like title or data will not be evaluated with ==. See equal? if you are looking for identity. More stringent comparisons will have to be done by hand!
347 348 349 |
# File 'lib/rubabel/molecule.rb', line 347 def ==(other) other.respond_to?(:csmiles) && (csmiles == other.csmiles) end |
#[](*args) ⇒ Object
retrieves the atom by index (accepts everything an array would)
146 147 148 |
# File 'lib/rubabel/molecule.rb', line 146 def [](*args) atoms[*args] end |
#add_atom!(arg = 6, bond_order = 1, attach_to = nil) ⇒ Object Also known as: <<
returns the atom passed in or that was created. arg is a pre-existing atom, an atomic number or an element symbol (e.g. :c). default is to add carbon.
136 137 138 139 140 141 |
# File 'lib/rubabel/molecule.rb', line 136 def add_atom!(arg=6, bond_order=1, attach_to=nil) attach_to ||= atoms.last atom = associate_atom!(arg) add_bond!(attach_to, atom, bond_order) if attach_to atom end |
#add_bond!(atom1, atom2, order = 1) ⇒ Object
takes a pair of Rubabel::Atom objects and adds a bond to the molecule returns whether the bond creation was successful.
473 474 475 |
# File 'lib/rubabel/molecule.rb', line 473 def add_bond!(atom1, atom2, order=1) @ob.add_bond(atom1.idx, atom2.idx, order) end |
#add_h!(ph = nil, polaronly = false) ⇒ Object
returns self. Corrects for ph if ph is not nil. NOTE: the reversal of arguments from the OpenBabel api.
251 252 253 254 255 256 257 258 |
# File 'lib/rubabel/molecule.rb', line 251 def add_h!(ph=nil, polaronly=false) if ph.nil? @ob.add_hydrogens(polaronly) else @ob.add_hydrogens(polaronly, true, ph) end self end |
#add_polar_h! ⇒ Object
only adds polar hydrogens. returns self
261 262 263 264 |
# File 'lib/rubabel/molecule.rb', line 261 def add_polar_h! @ob.add_polar_hydrogens self end |
#associate_atom!(arg) ⇒ Object
arg may be a Fixnum, a Symbol (Elemental symbol that is a Symbol), or a Rubabel::Atom. Returns the newly associated/created atom.
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 |
# File 'lib/rubabel/molecule.rb', line 113 def associate_atom!(arg) if arg.is_a?(Rubabel::Atom) @ob.add_atom(arg.ob) arg else (num, is_aromatic) = if arg.is_a?(Symbol) [Rubabel::ELEMENT_TO_NUM[arg], (arg.to_s.capitalize != arg.to_s)] else [arg, false] end new_obatom = @ob.new_atom new_obatom.set_atomic_num(num) new_obatom.set_aromatic if is_aromatic Rubabel::Atom.new(new_obatom) end end |
#atom(id) ⇒ Object
gets the atom by id
395 396 397 |
# File 'lib/rubabel/molecule.rb', line 395 def atom(id) @ob.get_atom_by_id(id).upcast end |
#atoms ⇒ Object
returns the array of atoms. Consider using #each
400 401 402 |
# File 'lib/rubabel/molecule.rb', line 400 def atoms each_atom.map.to_a end |
#bond(id) ⇒ Object
gets the bond by id
385 386 387 |
# File 'lib/rubabel/molecule.rb', line 385 def bond(id) @ob.get_bond_by_id(id).upcast end |
#bonds ⇒ Object
returns the array of bonds. Consider using #each_bond
390 391 392 |
# File 'lib/rubabel/molecule.rb', line 390 def bonds each_bond.map.to_a end |
#center! ⇒ Object
centers the molecule (deals with the atomic coordinate systems for 2D or 3D molecules). returns self.
647 648 649 650 |
# File 'lib/rubabel/molecule.rb', line 647 def center! @ob.center self end |
#charge ⇒ Object
158 |
# File 'lib/rubabel/molecule.rb', line 158 def charge() @ob.get_total_charge end |
#charge=(v) ⇒ Object
159 |
# File 'lib/rubabel/molecule.rb', line 159 def charge=(v) @ob.set_total_charge(v) end |
#convert_dative_bonds! ⇒ Object
returns self
640 641 642 643 |
# File 'lib/rubabel/molecule.rb', line 640 def convert_dative_bonds! @ob.convert_dative_bonds self end |
#correct_for_ph!(ph = 7.4) ⇒ Object
returns self. If ph is nil, then #neutral! is called
267 268 269 270 |
# File 'lib/rubabel/molecule.rb', line 267 def correct_for_ph!(ph=7.4) ph.nil? ? neutral! : @ob.correct_for_ph(ph) self end |
#csmiles ⇒ Object
returns just the smiles string (not the id)
313 314 315 |
# File 'lib/rubabel/molecule.rb', line 313 def csmiles to_s(:can) end |
#data ⇒ Object
returns a Rubabel::MoleculeData hash
525 526 527 |
# File 'lib/rubabel/molecule.rb', line 525 def data Rubabel::MoleculeData.new(@ob) end |
#delete(obj) ⇒ Object
obj is an atom or bond
433 434 435 436 437 438 439 440 441 442 |
# File 'lib/rubabel/molecule.rb', line 433 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 |
#delete_and_restore_bonds(*bonds, &block) ⇒ Object
yields self after deleting the specified bonds. When the block is closed the bonds are restored. Returns whatever is returned from the block.
480 481 482 483 484 485 486 487 488 489 |
# File 'lib/rubabel/molecule.rb', line 480 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 reply = block.call(self) bonds.each {|bond| @ob.add_bond(bond.ob) } reply end |
#delete_atom(atom) ⇒ Object
150 151 152 |
# File 'lib/rubabel/molecule.rb', line 150 def delete_atom(atom) @ob.delete_atom(atom.ob, false) end |
#delete_bond(*args) ⇒ Object
if given a bond, deletes it (doesn’t garbage collect). If given two atoms, deletes the bond between them.
446 447 448 449 450 451 452 453 |
# File 'lib/rubabel/molecule.rb', line 446 def delete_bond(*args) case args.size when 1 @ob.delete_bond(args[0].ob, false) when 2 @ob.delete_bond(args[0].get_bond(args[1]).ob, false) end end |
#delete_hydrogens! ⇒ Object Also known as: remove_h!, remove_hydrogens!
returns self
300 301 302 303 |
# File 'lib/rubabel/molecule.rb', line 300 def delete_hydrogens! @ob.delete_hydrogens self end |
#dim ⇒ Object
404 405 406 |
# File 'lib/rubabel/molecule.rb', line 404 def dim @ob.get_dimension end |
#do_with_hydrogens(ph = nil, polaronly = false, &block) ⇒ Object
ensures that hydrogens are added before an operation, but returns the molecule to the original hydrogen or no hydrogen state when finished. returns whatever was returned by the block.
233 234 235 236 237 238 239 |
# File 'lib/rubabel/molecule.rb', line 233 def do_with_hydrogens(ph=nil, polaronly=false, &block) hydr_added = @ob.has_hydrogens_added add_h!(ph, polaronly) unless hydr_added reply = block.call @ob.delete_hydrogens unless hydr_added reply end |
#do_without_hydrogens(ph = nil, polaronly = false, &block) ⇒ Object
241 242 243 244 245 246 247 |
# File 'lib/rubabel/molecule.rb', line 241 def do_without_hydrogens(ph=nil, polaronly=false, &block) hydr_added = @ob.has_hydrogens_added @ob.delete_hydrogens if hydr_added reply = block.call add_h!(ph, polaronly) if hydr_added reply end |
#each_atom(&block) ⇒ Object Also known as: each
iterates over the molecule’s Rubabel::Atom objects
352 353 354 355 356 357 358 359 360 361 |
# File 'lib/rubabel/molecule.rb', line 352 def each_atom(&block) # could use the C++ iterator in the future block or return enum_for(__method__) iter = @ob.begin_atoms atom = @ob.begin_atom(iter) while atom block.call atom.upcast atom = @ob.next_atom(iter) end end |
#each_bond(&block) ⇒ Object
iterates over the molecule’s Rubabel::Bond objects
365 366 367 368 369 370 371 372 373 374 375 |
# File 'lib/rubabel/molecule.rb', line 365 def each_bond(&block) # could use the C++ iterator in the future block or return enum_for(__method__) iter = @ob.begin_bonds obbond = @ob.begin_bond(iter) while obbond block.call obbond.upcast obbond = @ob.next_bond(iter) end self end |
#each_fragment(&block) ⇒ Object
504 505 506 507 508 509 |
# File 'lib/rubabel/molecule.rb', line 504 def each_fragment(&block) block or return enum_for(__method__) @ob.separate.each do |ob_mol| block.call( ob_mol.upcast ) end end |
#each_match(smarts_or_string, uniq = true, &block) ⇒ Object
yields atom arrays matching the pattern. returns an enumerator if no block is given
195 196 197 198 199 200 201 |
# File 'lib/rubabel/molecule.rb', line 195 def each_match(smarts_or_string, uniq=true, &block) block or return enum_for(__method__, smarts_or_string, uniq) _atoms = self.atoms smarts_indices(smarts_or_string, uniq).each do |ar| block.call(_atoms.values_at(*ar)) end end |
#equal?(other) ⇒ Boolean Also known as: eql?
checks to see if the molecules are the same OBMol object underneath by modifying one and seeing if the other changes. This is because openbabel routinely creates new objects that point to the same underlying data store, so even checking for OBMol equivalency is not enough.
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 |
# File 'lib/rubabel/molecule.rb', line 322 def equal?(other) return false unless other.is_a?(self.class) are_identical = false if self.title == other.title begin obj_id = self.object_id.to_s self.title += obj_id are_identical = (self.title == other.title) ensure self.title.sub(/#{obj_id}$/,'') end are_identical else false end end |
#exact_mass ⇒ Object
166 |
# File 'lib/rubabel/molecule.rb', line 166 def exact_mass() @ob.get_exact_mass end |
#formula ⇒ Object
returns a string representation of the molecular formula. Not sensitive to add_h!
175 |
# File 'lib/rubabel/molecule.rb', line 175 def formula() @ob.get_formula end |
#graph_diameter ⇒ Object
obconv.add_option(“u”,OpenBabel::OBConversion::OUTOPTIONS)
self
end
685 686 687 688 689 690 691 692 693 694 |
# File 'lib/rubabel/molecule.rb', line 685 def graph_diameter distance_matrix = Array.new self.atoms.each do |a| iter = OpenBabel::OBMolAtomBFSIter.new(self.ob, a.idx) while iter.inc.deref do distance_matrix << iter.current_depth - 1 end end distance_matrix.max end |
#highlight_substructure!(substructure, color = 'red') ⇒ Object
returns self
665 666 667 668 669 670 |
# File 'lib/rubabel/molecule.rb', line 665 def highlight_substructure!(substructure, color='red') tmpconv = OpenBabel::OBConversion.new tmpconv.add_option("s",OpenBabel::OBConversion::GENOPTIONS, "#{substructure} #{color}") self.ob.do_transformations(tmpconv.(OpenBabel::OBConversion::GENOPTIONS), tmpconv) self end |
#hydrogens_added? ⇒ Boolean Also known as: h_added?
are there hydrogens added yet
225 226 227 |
# File 'lib/rubabel/molecule.rb', line 225 def hydrogens_added? @ob.has_hydrogens_added end |
#initialize_copy(source) ⇒ Object
creates a deep copy of the molecule (even the atoms are duplicated)
378 379 380 381 382 |
# File 'lib/rubabel/molecule.rb', line 378 def initialize_copy(source) super @ob = OpenBabel::OBMol.new(source.ob) self end |
#inspect ⇒ Object
635 636 637 |
# File 'lib/rubabel/molecule.rb', line 635 def inspect "#<Mol #{to_s}>" end |
#kekulize! ⇒ Object
returns self
653 654 655 656 |
# File 'lib/rubabel/molecule.rb', line 653 def kekulize! @ob.kekulize self end |
#local_optimize!(forcefield = DEFAULT_FORCEFIELD, steps = 500) ⇒ Object
adds hydrogens if necessary. Performs only steepest descent optimization (no rotors optimized) returns self
556 557 558 559 560 561 562 563 564 565 566 567 |
# File 'lib/rubabel/molecule.rb', line 556 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 |
#make_3d!(forcefield = DEFAULT_FORCEFIELD, steps = 50) ⇒ Object Also known as: make3d!
does a bit of basic local optimization unless steps is set to nil returns self
578 579 580 581 582 583 |
# File 'lib/rubabel/molecule.rb', line 578 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 |
#mass ⇒ Object
returns the exact_mass corrected for charge gain/loss
169 170 171 |
# File 'lib/rubabel/molecule.rb', line 169 def mass @ob.get_exact_mass - (@ob.get_total_charge * Rubabel::MASS_E) end |
#matches(smarts_or_string, uniq = true) ⇒ Object
returns an array of matching atom sets. Consider using each_match.
204 205 206 |
# File 'lib/rubabel/molecule.rb', line 204 def matches(smarts_or_string, uniq=true) each_match(smarts_or_string, uniq).map.to_a end |
#matches?(smarts_or_string) ⇒ Boolean
208 209 210 211 |
# File 'lib/rubabel/molecule.rb', line 208 def matches?(smarts_or_string) # TODO: probably a more efficient way to do this using API smarts_indices(smarts_or_string).size > 0 end |
#mol_wt ⇒ Object Also known as: avg_mass
163 |
# File 'lib/rubabel/molecule.rb', line 163 def mol_wt() @ob.get_mol_wt end |
#neutral! ⇒ Object
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.
278 279 280 281 282 283 284 |
# File 'lib/rubabel/molecule.rb', line 278 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 |
#new_bond ⇒ Object
creates a new (as yet unspecified) bond associated with the molecule and gives it a unique id
467 468 469 |
# File 'lib/rubabel/molecule.rb', line 467 def new_bond @ob.new_bond.upcast end |
#num_atoms(count_implied_hydrogens = false) ⇒ Object
sensitive to add_h!
530 531 532 533 534 535 536 |
# File 'lib/rubabel/molecule.rb', line 530 def num_atoms(count_implied_hydrogens=false) if !count_implied_hydrogens @ob.num_atoms else @ob.num_atoms + reduce(0) {|cnt, atom| cnt + atom.ob.implicit_hydrogen_count } end end |
#num_bonds ⇒ Object
537 |
# File 'lib/rubabel/molecule.rb', line 537 def num_bonds() @ob.num_bonds end |
#num_hvy_atoms ⇒ Object
538 |
# File 'lib/rubabel/molecule.rb', line 538 def num_hvy_atoms() @ob.num_hvy_atoms end |
#num_residues ⇒ Object
539 |
# File 'lib/rubabel/molecule.rb', line 539 def num_residues() @ob.num_residues end |
#num_rotors ⇒ Object
540 |
# File 'lib/rubabel/molecule.rb', line 540 def num_rotors() @ob.num_rotors end |
#ob_fingerprint(type = DEFAULT_FINGERPRINT) ⇒ Object
returns a std::vector<unsigned int> that can be passed directly into the OBFingerprint.tanimoto method
425 426 427 428 429 430 |
# File 'lib/rubabel/molecule.rb', line 425 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 |
#ob_sssr ⇒ Object
returns an array of OpenBabel::OBRing objects.
214 215 216 |
# File 'lib/rubabel/molecule.rb', line 214 def ob_sssr @ob.get_sssr.to_a end |
#png_transformer(type_s, out_options = {}, &block) ⇒ Object
yields the type of object. Expects the block to yield the image string.
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 |
# File 'lib/rubabel/molecule.rb', line 587 def png_transformer(type_s, ={}, &block) = [:size] if type_s == 'png' png_output = true type_s = 'svg' if [:size] unless [:size].to_s =~ /x/i [:size] = [:size].to_s + 'x' + [:size].to_s end end else if [:size].is_a?(String) && ([:size] =~ /x/i) warn 'can only use the width dimension for this format' [:size] = [:size].split(/x/i).first end end image_blob = block.call(type_s, ) if png_output st = StringIO.new image = MiniMagick::Image.read(image_blob, 'svg') image.format('png') # would like to resize as an svg, then output the png of proper # granularity... image.resize([:size]) if [:size] image_blob = image.write(st).string end [:size] = image_blob end |
#smarts_indices(smarts_or_string, uniq = true) ⇒ Object
returns a list of atom indices matching the patterns (corresponds to the OBSmartsPattern::GetUMapList() method if uniq==true and GetMapList method if uniq==false). Note that the original GetUMapList returns atom numbers (i.e., the index + 1). This method returns the zero indexed indices.
186 187 188 189 190 191 |
# File 'lib/rubabel/molecule.rb', line 186 def smarts_indices(smarts_or_string, uniq=true) mthd = uniq ? :get_umap_list : :get_map_list pattern = smarts_or_string.is_a?(Rubabel::Smarts) ? smarts_or_string : Rubabel::Smarts.new(smarts_or_string) pattern.ob.match(@ob) pattern.ob.send(mthd).map {|atm_indices| atm_indices.map {|i| i - 1 } } end |
#smiles ⇒ Object
returns just the smiles string :smi (not the id)
308 309 310 |
# File 'lib/rubabel/molecule.rb', line 308 def smiles to_s(:smi) end |
#spin ⇒ Object
161 |
# File 'lib/rubabel/molecule.rb', line 161 def spin() @ob.get_total_spin_multiplicity end |
#split(*bonds) ⇒ Object
splits the molecules at the given bonds and returns the fragments. Does not alter the caller. If the molecule is already fragmented, then returns the separate fragments.
494 495 496 497 498 499 500 501 502 |
# File 'lib/rubabel/molecule.rb', line 494 def split(*bonds) if bonds.size > 0 delete_and_restore_bonds(*bonds) do |mol| mol.ob.separate.map(&:upcast) end else self.ob.separate.map(&:upcast) end end |
#strip_salts! ⇒ Object
returns self
659 660 661 662 |
# File 'lib/rubabel/molecule.rb', line 659 def strip_salts! @ob.strip_salts! self end |
#swap!(anchor1, to_move1, anchor2, to_move2) ⇒ Object
swaps to_move1 for to_move2 on the respective anchors returns self
461 462 463 464 |
# File 'lib/rubabel/molecule.rb', line 461 def swap!(anchor1, to_move1, anchor2, to_move2) OpenBabel::OBBuilder.swap(@ob, *[anchor1, to_move1, anchor2, to_move2].map {|at| at.ob.get_idx } ) self end |
#tanimoto(other, type = DEFAULT_FINGERPRINT) ⇒ Object
TODO: implement list of supported descriptors. (Not Yet Implemented!) def descs end
419 420 421 |
# File 'lib/rubabel/molecule.rb', line 419 def tanimoto(other, type=DEFAULT_FINGERPRINT) other.nil? ? 0 : Rubabel::Molecule.tanimoto(self, other, type) end |
#title ⇒ Object
attributes
155 |
# File 'lib/rubabel/molecule.rb', line 155 def title() @ob.get_title end |
#title=(val) ⇒ Object
156 |
# File 'lib/rubabel/molecule.rb', line 156 def title=(val) @ob.set_title(val) end |
#to_s(type = DEFAULT_OUT_TYPE) ⇒ Object
emits smiles without the trailing tab, newline, or id. Use write_string to get the default OpenBabel behavior (ie., tabs and newlines).
513 514 515 516 517 518 519 520 521 522 |
# File 'lib/rubabel/molecule.rb', line 513 def to_s(type=DEFAULT_OUT_TYPE) string = write_string(type) case type when :smi, :smiles, :can # remove name with openbabel options in the future string.split(/\s+/).first else string end end |
#write(filename_or_type = :can, out_options = {}) ⇒ Object
If filename_or_type is a symbol, then it will return a string of that type. If filename_or_type is a string, will write to the filename given no args, returns a DEFAULT_OUT_TYPE string
545 546 547 548 549 550 551 |
# File 'lib/rubabel/molecule.rb', line 545 def write(filename_or_type=:can, ={}) if filename_or_type.is_a?(Symbol) write_string(filename_or_type, ) else write_file(filename_or_type, ) end end |
#write_file(filename, out_options = {}) ⇒ Object
writes to the file based on the extension given (must be recognized by OpenBabel). If png is the extension or format, the png is generated from an svg.
630 631 632 633 |
# File 'lib/rubabel/molecule.rb', line 630 def write_file(filename, ={}) type = Rubabel.filetype(filename) File.write(filename, write_string(type, )) end |
#write_string(type = DEFAULT_OUT_TYPE, out_options = {}) ⇒ Object
out_options include any of those defined
618 619 620 621 622 623 624 625 |
# File 'lib/rubabel/molecule.rb', line 618 def write_string(type=DEFAULT_OUT_TYPE, ={}) png_transformer(type.to_s, ) do |type_s, _out_opts| obconv = [:obconv] || OpenBabel::OBConversion.new obconv.set_out_format(type_s) obconv.add_opts!(:out, _out_opts) obconv.write_string(@ob) end end |