molecules 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: Simon Chiang, Biomolecular Structure Program
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,73 @@
+= Molecules
+
+A library of molecules for scientific calculations in Ruby.
+
+== Description
+
+Molecules provides libraries of commonly used molecules (currently just amino
+acid residues and polypeptides).  Library classes inherit from EmpiricalFormula
+which allows calculation of molecular composition and mass, as well as
+adding/subtraction of other molecules.
+
+I have attempted to use reputable sources and to adhere to standards when 
+applicable.  Please notify me of any errors and send me suggestions!
+
+* Rubyforge[http://rubyforge.org/projects/bioactive]
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/13518-molecules/overview]
+* Github[http://github.com/bahuvrihi/molecules/tree/master]
+
+== Usage
+
+  require 'molecules'
+  include Molecules::Libraries
+  
+  # Residue predefines all common amino acids
+  # as well as some uncommon ones.
+  r = Residue::A
+  r.name               # => "Alanine"
+  r.abbr               # => "Ala"
+  r.letter             # => "A"
+  r.side_chain.to_s    # => "CH(3)"
+  r.mass               # => 71.03711
+  r.immonium_ion_mass  # => 44.0500
+  
+  # Polypeptide allows for creation of polypeptides
+  # from residue sequences.
+  p = Polypeptide.new("RPPGFSPFR")
+  p.to_s               # => "C(50)H(71)N(15)O(10)"
+  p.mass               # => 1041.5508
+  
+  # Generic molecules may be specified with EmpiricalFormula.
+  caffeine = Molecules::EmpiricalFormula.parse("C8H10N4O2")
+  coffee = Molecules::EmpiricalFormula.parse("C8H10N4O2 + H2O")
+
+=== Mass Calculator (tap task)
+
+Molecules provides a mass calculator tap task.  Tap[http://tap.rubyforge.org] 
+is not required by molecules in general, but you get this bonus if you have tap
+installed:
+
+  % tap -- molecules/calc ":RPPGFSPFR + H2O"
+    I[15:34:30]         1077.57 Da :RPPGFSPFR + H2O
+
+== Known Issues
+
+* Polypeptide only allows common residues
+* No 'Molecule' class is defined, pending the potential addition
+  of more molecule data (ex: SMILES[http://en.wikipedia.org/wiki/Simplified_molecular_input_line_entry_specification]
+  data)
+* No mechanism for defining large libraries of molecules has been
+  chosen.  A database solution may be adopted to this end.
+  
+== Installation
+
+Molecules is available as a gem through RubyForge[http://rubyforge.org/projects/bioactive].  Use:
+
+  % gem install molecules
+
+== Info 
+
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: MIT-Style

data/Rakefile

@@ -0,0 +1,78 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'yaml'
+
+# tasks
+desc 'Default: Run tests.'
+task :default => :test
+
+desc 'Run tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = File.join('test', ENV['subset'] || '', ENV['pattern'] || '**/*_test.rb')
+  t.verbose = true
+end
+
+#
+# admin tasks
+#
+
+def gemspec
+  data = File.read("molecules.gemspec")
+  spec = nil
+  Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  spec
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_tar = true
+end
+
+task :print_manifest do
+  # collect files from the gemspec, labeling 
+  # with true or false corresponding to the
+  # file existing or not
+  files = gemspec.files.inject({}) do |files, file|
+    files[File.expand_path(file)] = [File.exists?(file), file]
+    files
+  end
+  
+  # gather non-rdoc/pkg files for the project
+  # and add to the files list if they are not
+  # included already (marking by the absence
+  # of a label)
+  Dir.glob("**/*").each do |file|
+    next if file =~ /^(rdoc|pkg)/ || File.directory?(file)
+    
+    path = File.expand_path(file)
+    files[path] = ["", file] unless files.has_key?(path)
+  end
+  
+  # sort and output the results
+  files.values.sort_by {|exists, file| file }.each do |entry| 
+    puts "%-5s : %s" % entry
+  end
+end
+
+desc 'Generate documentation.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "molecules"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include(["README", 'MIT-LICENSE'])
+  rdoc.rdoc_files.include(gemspec.files.select {|file| file =~ /^lib/})
+end
+
+desc "Publish RDoc to RubyForge"
+task :publish_rdoc => [:rdoc] do
+  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
+  host = "#{config["username"]}@rubyforge.org"
+  
+  rsync_args = "-v -c -r"
+  remote_dir = "/var/www/gforge-projects/bioactive/molecules"
+  local_dir = "rdoc"
+ 
+  sh %{rsync #{rsync_args} #{local_dir}/ #{host}:#{remote_dir}}
+end

data/lib/molecules.rb

@@ -0,0 +1,4 @@
+$: << File.dirname(__FILE__)
+
+require 'molecules/libraries/residue'
+require 'molecules/libraries/polypeptide'

data/lib/molecules/calc.rb

@@ -0,0 +1,127 @@
+require 'molecules/empirical_formula'
+require 'molecules/libraries/polypeptide'
+
+# patch for ruby units
+class Unit < Numeric # :nodoc:
+  UNIT_DEFINITIONS['<AMU>'] = [%w{u AMU amu}, 1/6.0221415e26, :mass, %w{<kilogram>}]
+  UNIT_DEFINITIONS['<dalton>'] = [%w{Da Dalton Daltons dalton daltons}, 1/6.0221415e26, :mass, %w{<kilogram>}]
+end
+Unit.setup
+
+module Molecules
+
+  # :startdoc::manifest a mass calculator
+  # Calculates the mass of a molecule or empirical formula.  The
+  # options can be used to alter the output (precision, mass
+  # calculation method etc.)  You may enter compound formulae, or
+  # a list of formulae.  In addition, polypeptides can be specified 
+  # using the one-letter residue codes:
+  #
+  #   % tap -- molecules/calc H2O
+  #     I[17:09:00]   18.0105646863 Da H2O
+  #
+  #   % tap -- molecules/calc H2O -u kg
+  #     I[13:35:59]    2.99072e-026 kg H2O
+  #
+  #   % tap -- molecules/calc 'C3H5NO + H2O' C50H73N15O11 -p 2
+  #     I[17:08:21]           89.05 Da C3H5NO + H2O
+  #     I[17:08:21]         1059.56 Da C50H73N15O11
+  #
+  #   % tap -- molecules/calc :RPPGFSPFR
+  #     I[13:35:02]         1059.56 Da :RPPGFSPFR
+  #
+  # Furthermore, if a unimod path is specified in the configurations,
+  # unimod modifcations may be specified by name as the polypeptide
+  # termini.  Use '%' signs as in a SQL query to shorten the name:
+  #
+  #   % tap -- molecules/calc 'Acetyl:RPPGFSPFR:Hydroxyl%' --unimod-path <...>
+  #     I[13:33:25]         1059.56 Da Acetyl:RPPGFSPFR:Hydroxyl%
+  #
+  # The unimod path must point to an sqlite3 ActiveUnimod database, and 
+  # sqlite3-ruby must be installed for this feature to work.
+  # 
+  #   * ActiveUnimod[http://bioactive.rubyforge.org/]
+  #   * sqlite3-ruby[http://rubyforge.org/projects/sqlite-ruby/]
+  #  
+  class Calc < Tap::Task
+  
+    config :type, :monoisotopic                             # the mass type calculated
+    config :precision, nil, :short => 'p'                   # the precision of the mass
+    config :units, "Da", :short => 'u', &c.string           # the mass unit reported
+    config :composition, false, :short => 'c', &c.flag      # reports the composition, not the formula
+    config :unimod_path, nil do |path|                      # the path to the unimod database
+      case
+      when path == nil then nil
+      when File.exists?(path) then path
+      else raise "path to unimod db does not exist: #{path}"
+      end
+    end
+    
+    # Formulates a query for a modification matching code_name 
+    # for the unimod database.  If the code_name contains a '%'
+    # then the query will use a LIKE syntax, otherwise the 
+    # code_name will be searced for exactly.
+    def mod_query(code_name)
+      # should do a rails-like escape on code_name
+      "SELECT code_name, composition FROM modifications WHERE code_name #{code_name.include?('%') ? 'LIKE' : '='} '#{code_name}'"
+    end
+    
+    # Attempts to find and instantiate an EmpiricalFormula for
+    # a unimod modification matching code_name.
+    def find_mod(code_name)
+      raise "no unimod_path was specified" if unimod_path == nil
+      require 'sqlite3' unless Object.const_defined?(:SQLite3)
+      
+      results = []
+      db = SQLite3::Database.new(unimod_path)
+      db.execute(mod_query(code_name)) do |row|
+        results << row
+      end
+      db.close
+      
+      case results.length
+      when 1 then EmpiricalFormula.parse_simple(results[0][1])
+      when 0 then raise "could not find modification: #{code_name}"
+      else raise "multiple modifications found for: #{code_name} (#{results.collect {|result| result[0]}.join(', ')})"
+      end
+    end
+    
+    WATER = EmpiricalFormula.parse "H2O"
+    HYDROGEN = EmpiricalFormula.parse "H"
+    HYDROXIDE = EmpiricalFormula.parse "OH"
+    
+    # Returns an array of the calculated masses, in the correct unit.
+    def process(*formulae)
+      formulae.collect do |formula_str|
+        formula = EmpiricalFormula.parse(formula_str) do |str|
+          case str
+          when /^(.*?):([A-Z]+):?(.*)$/
+            peptide = Libraries::Polypeptide.new($2) + WATER
+            peptide += find_mod($1) unless $1.to_s.empty? 
+            peptide += find_mod($3) unless $3.to_s.empty?
+            peptide
+          else nil
+          end
+        end
+
+        mass = formula.mass do |element|
+          case type
+          when :monoisotopic then element.mass
+          when :average then element.std_atomic_weight.value
+          else raise "unknown mass type: #{type}"
+          end
+        end
+
+        mass = Unit.new(mass, "Da").convert_to(units)
+        unless precision == nil
+          mass = Unit.new( Utils.round(mass.scalar, precision), units) 
+        end
+        
+        log mass, composition ? formula : formula_str
+
+        mass
+      end
+    end
+    
+  end
+end

data/lib/molecules/empirical_formula.rb

@@ -0,0 +1,325 @@
+require 'constants/libraries/element'
+require 'molecules/utils'
+require 'strscan'
+
+module Molecules
+  Element = Constants::Libraries::Element
+  
+  # EmpiricalFormula represents the empirical formula (ex 'H(2)0') for
+  # a molecule.  The formula is stored as an array of integers aligned
+  # to the elements in EmpiricalFormula::ELEMENT_INDEX.  Hence:
+  #
+  #   EmpiricalFormula::ELEMENT_INDEX[0].name   # => "Hydrogen"
+  #   EmpiricalFormula::ELEMENT_INDEX[1].name   # => "Oxygen"
+  #
+  #   water = EmpiricalFormula.new [2,1]
+  #   water.to_s                                # => 'H(2)O'
+  #   water.mass                                # => 18.0105646863
+  #
+  # EmpiricalFormula may be added, subtracted, and multiplied to
+  # perform the expected operations:
+  #
+  #   alanine = EmpiricalFormula.new [5,1,3,1]
+  #   (alanine - water).formula                 # => [3,0,3,1]
+  #
+  class EmpiricalFormula
+    class << self
+
+      # Parses a simple formula (formatted like those returned by 
+      # EmpiricalFormula#to_s) into a EmpiricalFormula. Whitespace 
+      # is allowed in the formula.
+      # 
+      #   EmpiricalFormula.parse("H(2)O").to_s           # => "H(2)O"
+      #   EmpiricalFormula.parse("H (2) O").to_s         # => "H(2)O"
+      #   EmpiricalFormula.parse("HO(-1)O(2)H").to_s     # => "H(2)O"
+      #
+      def parse_simple(chemical_formula)
+        formula = chemical_formula.to_s.gsub(/\s+/, "")
+
+        factor = nil
+        composition = Hash.new(0)
+        scanner = StringScanner.new(formula.reverse)
+        while scanner.restsize > 0
+          case
+          when scanner.scan_full(/\)(\d+-?)\(/, true, false)
+            # found a factor
+            factor = scanner[1].reverse.to_i
+          when scanner.scan_full(/([a-z]?[A-Z])/, true, false)
+            # found an element
+            composition[scanner[1].reverse] += (factor == nil ? 1 : factor)
+
+            # reset factor to nil
+            factor = nil
+          else
+            raise ParseError.new("could not parse formula: #{chemical_formula}")
+          end
+        end
+        factors = composition_to_factors(composition)
+        block_given? ? yield(factors) : EmpiricalFormula.new(factors)
+      end
+
+      # Parses a generalized chemical formula into an EmpiricalFormula.
+      # Formula sections can be nested with parenthesis, and multiple
+      # sections can be added or subtracted within the formula.  
+      #
+      #   EmpiricalFormula.parse("H2O").to_s                   # => "H(2)O"
+      #   EmpiricalFormula.parse("CH3(CH2)50CH3").to_s         # => "C(52)H(106)"
+      #   EmpiricalFormula.parse("C2H3NO - H2O + NH3").to_s    # => "C(2)H(4)N(2)"
+      #
+      # Note that the format for EmpiricalFormula#to_s differs from the 
+      # format that parse utilizes.
+      #
+      # To extend the functionality of parse, provide a block to receive
+      # formula sections with unexpected punctuation and calculate an 
+      # EmpiricalFormula therefrom.  If the block returns nil, 
+      # then parse will raise an error.
+      #
+      #   block = lambda do |formula|
+      #     case formula
+      #     when /\[(.*)\]/
+      #       factors = $1.split(/,/).collect {|i| i.strip.to_i }
+      #       EmpiricalFormula.new(factors)
+      #     else nil
+      #     end
+      #   end
+      #
+      #   EmpiricalFormula.parse("H2O + [2, 1]", &block).to_s   # => "H(4)O(2)"
+      #   EmpiricalFormula.parse("H2O + :not_expected", &block) # !> ParseError
+      #
+      def parse(chemical_formula, &block)
+        # Remove whitespace 
+        formula = chemical_formula.to_s.gsub(/\s+/, "")
+
+        # Split and handle multipart formulae
+        case formula 
+        when /\+/
+          return formula.split(/\+/).inject(EmpiricalFormula.new) do |current, formula|
+            current + parse(formula, &block)
+          end
+        when /-/
+          splits = formula.split(/-/)
+          first = parse(splits.shift, &block)
+          return splits.inject(first) do |current, formula|
+            current - parse(formula, &block)
+          end
+        when /[^A-Za-z0-9\\(\\)]/
+          result = block_given? ? yield(formula) : nil
+          return result unless result == nil
+          
+          raise ParseError.new("unexpected characters in formula: #{chemical_formula}")
+        end
+
+        # factor is the number following an element, as 6 and 12 in 'C6H12'
+        # factor == -1 indicates that a number has not been read for the 
+        # next element.  This state is used later to check for hanging 
+        # factors, as in '2C6' or (8OH)
+        factor = nil
+
+        # multiplier is the latest cumulative factor for a parenthesis 
+        # expression.  A new multiplier is pushed on the stack for every new
+        # parenthesis set, and popped off when the set terminates.
+        # ex: for CH3(C(H)2)7CH 
+        #   At the period       Integer at the top of the stack equals
+        #   CH3(C(H)2)7.CH      1
+        #   CH3(C(H)2.)7CH      7
+        #   CH3(C(H.)2)7CH      14
+        #   CH3(C.(H)2)7CH      7
+        #   CH3.(CH)2)7CH       1
+        multiplier = []
+        multiplier << 1
+
+        # composition will store the formula composition as it is parsed
+        composition = Hash.new(0)
+
+        # Parse elements and factors out of the formula from right to left     
+        scanner = StringScanner.new(formula.reverse)
+        while scanner.restsize > 0
+
+          case
+          when scanner.scan_full(/(\d+)/, true, false)
+            # found a factor
+            factor = scanner[1].reverse.to_i
+          when scanner.scan_full(/([a-z]?[A-Z])/, true, false)
+            # found an element
+
+            # Adjust the factor by the multiplier.  If factor == nil 
+            # then a factor has not been read for the element, as would
+            # be seen in NaOH; use 1 in this case instead.
+            factor = (factor.nil? ? 1 : factor) * multiplier.last
+
+            # Add the current factor to composition, remembering to reverse the symbol
+            composition[ scanner[1].reverse ] += factor
+
+            # reset factor to nil
+            factor = nil
+          when scanner.scan_full(/\)/, true, false)
+            # When a parenthesis ends, the current multiplier must be
+            # adujusted by the current factor.  If factor == nil then a 
+            # factor has not been read for the parenthesis, use 1 instead
+            multiplier << (factor.nil? ? 1 : factor) * multiplier.last
+
+            # reset factor to nil
+            factor = nil
+          when scanner.scan_full(/\(/, true, false)
+            # When a parenthesis starts, the current multiplier is
+            # popped off.  Check for hanging factors and that after 
+            # popping a multiplier will remain.  If no multiplier will
+            # remain, then the parenthesis must be mismatched
+            raise ParseError.new("the formula contains a hanging factor: #{chemical_formula}") unless factor.nil?
+            raise ParseError.new("the formula contains mismatched parenthesis: #{chemical_formula}") unless multiplier.length > 1
+
+            multiplier.pop
+          else
+            raise ParseError.new("could not parse formula: #{chemical_formula}")
+          end
+        end
+
+        # Check for hanging factors, that a multiplier remains, and that 
+        # elements were found during parsing
+        raise ParseError.new("the formula contains a hanging factor: #{chemical_formula}") unless factor.nil?
+        raise ParseError.new("the formula contains mismatched parenthesis: #{chemical_formula}") unless multiplier.length == 1
+        raise ParseError.new("no elements could be found in the formula: #{chemical_formula}") if composition.length == 0 && !formula.empty?
+
+        EmpiricalFormula.new(composition_to_factors(composition))
+      end
+
+      # Parses the input formula into an EmpiricalFormula and 
+      # calculates the mass therefrom.  By default the mass 
+      # will be the monoisotopic mass of the formula.
+      #
+      # See EmpericalFormula#mass for more details.
+      def mass(formula, &block) # :yields: element
+        mass = parse(formula).mass(&block)
+      end
+      
+      protected
+      
+      # Converts a hash of (symbol, factor) pairs into a factors array,
+      # suitable for initializing an EmpiricalFormula.
+      def composition_to_factors(composition)
+        factors = []
+        composition.each_pair do |symbol, factor|
+          next if factor == 0
+
+          element = symbol.kind_of?(Element) ? symbol : Element.index(:symbol)[symbol]
+          if element == nil
+            raise UnknownElementError.new("unknown element: #{symbol}")
+          end
+
+          factors[ELEMENT_INDEX.index(element)] = factor
+        end
+        factors
+      end
+    end
+    
+    class UnknownElementError < StandardError # :nodoc:
+    end
+
+    class ParseError < StandardError # :nodoc:
+    end
+    
+    include Enumerable
+    include Utils
+
+    # An array defining the number of a given element in the formula.  The
+    # order of elements in ELEMENT_INDEX correspond to order of forumula,
+    # such that formula[1] indicates the number of ELEMENT_INDEX[1] elements
+    # in self.
+    attr_reader :formula
+
+    def initialize(formula=[], normalize=true)
+      @formula = formula
+
+      if normalize
+        # normalize by converting nils to zero and remove trailing zeros
+        @formula.collect! {|factor| factor == nil ? 0 : factor}
+        @formula.pop while @formula.last == 0
+      end
+
+      # ensure the formula cannot be changed
+      @formula.freeze
+    end
+
+    # Returns a new EmpiricalFormula summing the formula of another and self.
+    def +(another)
+      EmpiricalFormula.new(add(self.formula.dup, another.formula), false)
+    end
+
+    # Returns a new EmpiricalFormula subtracting the formula of another from self.
+    def -(another)
+      EmpiricalFormula.new(add(self.formula.dup, another.formula, -1), false)
+    end
+
+    # Returns a new EmpiricalFormula multiplying the formula of self by factor.
+    def *(factor)
+      EmpiricalFormula.new(multiply(self.formula.dup, factor), false)
+    end
+
+    # True if another is an EmpiricalFormula and the formula of another equals the formula of self.
+    def ==(another)
+      another.kind_of?(EmpiricalFormula) && self.formula == another.formula
+    end
+
+    # Yields each element and the number of times that element occurs in self.
+    def each # :yields: element, n
+      formula.each_with_index do |n, index|
+        next if n == 0
+        yield(ELEMENT_INDEX[index], n)
+      end
+    end
+
+    # Returns a formula string formatted like 'H(2)O' with the 
+    # elements are sorted alphabetically by symbol.
+    def to_s
+      collect do |element, n|
+        element.symbol + (n == 1 ? "" : "(#{n})")
+      end.sort.join('')
+    end
+    
+    # Calculates and returns the mass of self using the element
+    # masses returned by the block. Returns the monoisotopic mass 
+    # for the formula (ie the mass calculated from the most abundant 
+    # natural isotope of each element) if no block is given.
+    #
+    #   water = EmpiricalFormula.new [2,1]
+    #
+    #   # monoisotopic mass calculation
+    #   water.mass                                    # => 18.0105646863
+    #   water.mass {|e| e.mass }                      # => 18.0105646863 
+    #   
+    #   # average mass calculation
+    #   water.mass {|e| e.std_atomic_weight.value }   # => 18.01528
+    #
+    # ==== Notes
+    # - The definition of monoisotopic mass conforms to
+    #   that presented in 'Standard Definitions of Terms Relating 
+    #   to Mass Spectrometry, Phil. Price, J. Am. Soc. Mass 
+    #   Spectrom. (1991) 2 336-348' 
+    #   (see {Unimod Mass Help}[http://www.unimod.org/masses.html])
+    # - Masses are calculated such that mathematical operations 
+    #   are performed on the return of the block.
+    # 
+    def mass(&block)
+      if block_given? 
+        mass = 0
+        each {|e, n| mass = (yield(e) * n) + mass }
+        mass
+      else
+        @monoisotopic_mass ||= mass {|e| e.mass}
+      end
+    end
+    
+    # An array of all element symbols ordered roughly by their occurence
+    # in common biological molecules (ex water, carbohydrates, proteins).  
+    ELEMENT_INDEX_ORDER = ['H', 'O', 'C', 'N', 'S', 'P', 'Fe', 'Ni', 'Se']
+    
+    # An array of all elements ordered as in ELEMENT_INDEX_ORDER
+    ELEMENT_INDEX = Element.library.collect :element_index do |e|
+      unless ELEMENT_INDEX_ORDER.include?(e.symbol)
+        ELEMENT_INDEX_ORDER << e.symbol
+      end
+      
+      [e, ELEMENT_INDEX_ORDER.index(e.symbol)]
+    end
+  end
+end