MS-fragmenter 0.0.2

data/lib/charge_calculator.rb

@@ -0,0 +1,80 @@
+module MS
+  class ChargeCalculator
+# This is straight from my pI calculator, and adds the fxn of calculating a maximum charge state for the total peptide, given the sequence.
+#
+#	Usage:  charge_at_pH(identify_potential_charges(peptide_sequence), pH_desired)
+    PepCharges = Struct.new(:seq, :n_term, :c_term, :y_num, :c_num, :k_num, :h_num, :r_num, :d_num, :e_num, :pi)
+    def self.identify_potential_charges(str)
+      string = str.upcase
+      first = string[0]; last = string[-1]
+      puts string if first.nil? or last.nil?
+      begin
+        out = PepCharges.new(string, PkTable[first.to_sym][0], PkTable[last.to_sym][1], 0, 0, 0 ,0 ,0 ,0, 0)
+      rescue NoMethodError
+        abort string
+      end
+      string.chars.each do |letter|
+        case letter
+          when "Y" 
+            out.y_num += 1 
+          when "C"
+            out.c_num += 1
+          when "K"
+            out.k_num += 1 
+          when "H"
+            out.h_num += 1
+          when "R"
+            out.r_num += 1
+          when "D"
+            out.d_num += 1
+          when "E"
+            out.e_num += 1
+        end
+      end
+      out
+    end # Returns the PepCharges structure
+
+    PkTable = {
+      :K => [2.18,8.95,10.53], 
+      :E => [2.19,9.67,4.25], 
+      :D => [1.88,9.60,3.65], 
+      :H => [1.82,9.17,6.00],
+      :R => [2.17,9.04,12.48],
+      :Q => [2.17,9.13,nil],
+      :N => [2.02,8.80,nil],
+      :C => [1.96,10.28,8.18],
+      :T => [2.11,9.62,nil],
+      :S => [2.21,9.15,nil],
+      :W => [2.38,9.39,nil],
+      :Y => [2.20,9.11,10.07],
+      :F => [1.83,9.13,nil],
+      :M => [2.28,9.21,nil],
+      :I => [2.36,9.68,nil],
+      :L => [2.36,9.60,nil],
+      :V => [2.32,9.62,nil],
+      :P => [1.99,10.96,nil],
+      :A => [2.34,9.69,nil],
+      :G => [2.34,9.60,nil],
+# These are the fringe cases... B and Z... Jerks, these are harder to calculate pIs
+      :B => [1.95,9.20,3.65],
+      :Z => [2.18,9.40,4.25],
+      :X => [2.20,9.40,nil],
+      :U => [1.96,10.28,5.20] # Unfortunately, I've only found the pKr for this... so I've used Cysteine's values.
+    }
+
+    def self.charge_at_pH(pep_charges, pH)
+      charge = 0
+      charge += -1/(1+10**(pep_charges.c_term-pH))
+      charge += -pep_charges.d_num/(1+10**(PkTable[:D][2]-pH))
+      charge += -pep_charges.e_num/(1+10**(PkTable[:E][2]-pH))
+      charge += -pep_charges.c_num/(1+10**(PkTable[:C][2]-pH))
+      charge += -pep_charges.y_num/(1+10**(PkTable[:Y][2]-pH))
+      charge += 1/(1+10**(pH - pep_charges.n_term))
+      charge += pep_charges.h_num/(1+10**(pH-PkTable[:H][2]))
+      charge += pep_charges.k_num/(1+10**(pH-PkTable[:K][2]))
+      charge += pep_charges.r_num/(1+10**(pH-PkTable[:R][2]))
+      charge
+    end #charge_at_pH
+  end # class ChargeCalculator
+end
+

data/lib/fragmenter.rb

@@ -0,0 +1,184 @@
+require_relative 'fragmenter/masses'
+require_relative 'charge_calculator'
+module MS
+  class Fragmenter
+    include MS
+
+    attr_accessor :list
+    TableEntry = Struct.new(:ion, :seq, :mass, :charge, :composition_arr)
+    Ion_Defaults = {:b => true, :y => true}
+    Defaults = {:charge_states => true, :avg => false}
+    def initialize(opts = {}, ion_opts = {})
+      set_options(opts, ion_opts)
+      self
+    end
+    def set_options(opts, ion_opts)
+      #@opts = Default_fragments.merge(opts)
+      opts = Defaults.merge(opts)
+      ion_opts = Ion_Defaults.merge(ion_opts)
+      @n_term_search_ion_types = []
+      @c_term_search_ion_types = []
+      @max_charge = 1 unless opts[:charge_states]
+      #puts "options :charge_states = #{opts[:charge_states]}"
+      ion_opts.each do |key, v|
+        if v
+          case key 
+            when :b
+              @n_term_search_ion_types.push(:b, :b_star, :b_not)
+            when :a
+              @n_term_search_ion_types.push(:a, :a_star, :a_not)
+            when :c
+              @n_term_search_ion_types << :c
+            when :x
+              @c_term_search_ion_types << :x
+            when :y
+              @c_term_search_ion_types.push(:y, :y_star, :y_not)
+            when :z
+              @c_term_search_ion_types << :z
+          end
+        end
+      end
+      @mass_list = opts[:avg] ? MS::AvgResidueMasses : MS::MonoResidueMasses
+      #putsv "@mass_list: #{@mass_list}"
+    end #set_options
+      
+    def calculate_fragments(sequence)
+      arr = sequence.upcase.split('')
+      out = [[],[]]
+      (0..arr.size-2).each do |i|
+        out[0] << arr[0..i].join
+        out[1] <<  arr[(i+1)..-1].join
+      end
+      out
+    end
+# This fxn exists to provide the API consistent with John's request for the 689R class.
+# Options may include a list of fragment classes as symbols (i.e. :b, :y)
+    def fragment(pep_seq, options={}) # TODO handle an intensity option to handle normalization and scaling...?
+      set_options(options) unless options.empty?
+      generate_fragment_masses(pep_seq)
+      @list.map(&:mass)
+    end
+    def generate_fragment_masses(sequence) # Returns the TableEntry object which should be easy to use for table generation
+      @sequence = sequence
+      @max_charge ||= MS::ChargeCalculator.charge_at_pH(MS::ChargeCalculator.identify_potential_charges(sequence), 2).ceil
+      ### Calculate the base ion masses	
+      n_terms, c_terms = calculate_fragments(sequence)
+      n_terms.map! do |seq|
+        mass = MS::NTerm
+        seq.chars.map(&:to_sym).each do |residue|
+          mass += @mass_list[residue]
+        end
+        [seq, mass]
+      end
+      c_terms.map! do |seq|
+        mass = MS::CTerm
+        seq.chars.map(&:to_sym).each do |residue|
+          mass += @mass_list[residue]
+        end
+        [seq, mass]
+      end
+### Tablify and generate a comprehensive list of ions
+      list = []
+      send_to_list = lambda do |fragment_arr, iontypes_arr|
+        fragment_arr.each do |n_terms|
+          seq = n_terms.first
+          mass = n_terms.last
+          iontypes_arr.each do |iontype|
+            (1..@max_charge).each do |charge|
+              charge_legend = '+'*charge
+              list << TableEntry.new("#{iontype}(#{seq.size})#{charge_legend}".to_sym, seq, charge_state(mass + IonTypeMassDelta[iontype], charge), charge)
+            end # 1..max_charge
+          end	# iontypes_arr
+        end # fragment_arr
+      end # lambda block
+      send_to_list.call(n_terms, @n_term_search_ion_types)
+      send_to_list.call(c_terms, @c_term_search_ion_types)		
+      @list = list
+    end	
+    def to_mgf(seq = nil)
+      if seq.nil?
+        seq = @sequence
+        list = @list
+      else
+        list = generate_fragment_masses(seq)
+      end
+      intensity = 1000 # An arbitrary intensity value
+      output_arr = []
+      output_arr << %Q{COM=Project: In-silico Fragmenter\nBEGIN IONS\nPEPMASS=#{precursor_mass(seq, @max_charge)}\nCHARGE=#{@max_charge}+\nTITLE=Label: Sequence is #{seq}}
+      list.sort_by{|a| a.mass}.each do |table_entry|
+        #	TableEntry = Struct.new(:ion, :seq, :mass, :charge)
+        output_arr << "#{"%.5f" % table_entry.mass }\t#{intensity}"
+      end
+      output_arr << "END IONS"
+      File.open("#{seq}.mgf", 'w') {|o| o.print output_arr.join("\n") }
+      output_arr.join("\n")
+    end
+    def graph(list = nil)
+      list ? list : list = @list
+      require 'rserve/simpler'
+      robj = Rserve::Simpler.new
+      hash = {}
+      hash["mass"] = list.map(&:mass)
+      hash["intensity"] = list.map{ 1000.0} # Hacky standard intensity value
+      robj.converse( masses: hash.to_dataframe) do 
+        "attach(masses)"
+      end
+      #robj.converse( data: Rserve::DataFrame.from_structs(list))
+      robj.converse "setwd('#{Dir.pwd}')"
+      output_file_name = "#{@sequence}_spectra.png"
+      robj.converse do 
+        %Q{png(file='#{output_file_name}')
+          plot(masses$mass, masses$intensity, type='h')
+          dev.off()
+      }
+      end	
+      output_file_name
+    end
+  end
+end
+          
+       
+######### Testing stuff
+if $0 == __FILE__
+  require 'optparse'
+  options = {charge_states: true, avg: false}
+  ion_options = {}
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename(__FILE__)} sequence [options]"
+    opts.separator "Output: [Array] (containing fragment ion masses)"
+
+    opts.on('--ion_type a,b,c,x,y,z', Array, "Select ion types (default is b,y)") do |t|
+      arr = t.map{|a| a.downcase.to_sym}
+      hash = {}
+      arr.each {|a| hash[a] = true}
+      ion_options[:ion_types] = hash
+    end
+    opts.on('--[no-]charge_states', "Turn on or off the charge state output") do |s|
+      options[:charge_states] = s
+    end
+    opts.on('-a', '--avg', "Use average masses to calculate ions instead of monoisotopic masses") do |a|
+      options[:avg] = a
+    end
+    if ARGV.size == 0
+      puts opts
+      exit
+    end
+    opts.on('--[no-]charge_states', "Turn off output of multiple charge states in list") do |s|
+      options[:charge_states] = s
+    end
+    opts.on() do 
+
+    end
+
+    opts.on_tail('-h', '--help', "Show this message") do 
+      puts opts
+      exit
+    end
+  end.parse!  # OptionParser
+  if ARGV.size >= 1
+    f = Fragmenter.new(options, ion_options)
+    f.fragment(ARGV.first)
+    puts "I graphed these fragments and wrote them to #{f.graph} for you."
+  end  
+end # $0 == __FILE__
+

data/lib/fragmenter/masses.rb

@@ -0,0 +1,119 @@
+module MS
+  Proton = 1.00782503207
+	def precursor_mass(seq, charge)
+		mass = NTerm + CTerm
+		seq.chars.map(&:to_sym).each do |residue|
+			mass += MS::MonoResidueMasses[residue]
+		end
+		charge_state(mass, charge)
+	end
+		
+	def charge_state(mass, charge)
+		if charge > 0
+			(mass + charge) / charge.to_f
+		else
+			(mass - charge) / charge.to_f
+		end
+	end
+
+	IonTypeMassDelta = {
+		a:  (- 29.00273),
+		a_star: (-(29.00273+17.02654)),
+		a_not:	(-(17.02654 + 29.00273+18.01056)),
+		b: (-1.00782),
+		b_star: ( - 1.00782 - 17.02654),
+		b_not: (-17.02654 - 1.00782 - 18.01056),
+		c: (16.01872),
+		x: (27.99491 - 1.00782),
+		y: (1.00782),
+		y_star: (1.00782  - 17.02654),
+		y_not: (1.00782 - 18.01056),
+		z: (- 16.01872)
+	}
+	
+	NTerm =	1.00782
+
+	CTerm =	27.99491 - 10.9742
+
+	MonoResidueMasses = {
+		:A => 71.037114, 
+		:R => 156.101111,
+		:N => 114.042927,
+		:D => 115.026943,
+		:C => 103.009185,
+		:E => 129.042593,
+		:Q => 128.058578, 
+		:G => 57.021464,
+		:H => 137.058912,
+		:I => 113.084064,
+		:L => 113.084064,
+		:K => 128.094963,
+		:M => 131.040485,
+		:F => 147.068414,
+		:P => 97.052764,
+		:S => 87.032028,
+		:T => 101.047679,
+		:U => 150.95363,
+		:W => 186.079313,
+		:Y => 163.06332,
+		:V => 99.068414,
+    :* => 118.805716,
+    :B => 172.048405,
+    :X => 118.805716,
+    :Z => 128.550585
+	}
+  AvgResidueMasses = {
+    :* => 118.88603, 
+    :A => 71.0779, 
+    :B => 172.1405, 
+    :C => 103.1429, 
+    :D => 115.0874, 
+    :E => 129.11398, 
+    :F => 147.17386, 
+    :G => 57.05132, 
+    :H => 137.13928, 
+    :I => 113.15764, 
+    :K => 128.17228, 
+    :L => 113.15764, 
+    :M => 131.19606, 
+    :N => 114.10264, 
+    :O => 211.28076, 
+    :P => 97.11518, 
+    :Q => 128.12922, 
+    :R => 156.18568, 
+    :S => 87.0773, 
+    :T => 101.10388, 
+    :U => 150.0379, 
+    :V => 99.13106, 
+    :W => 186.2099, 
+    :X => 118.88603, 
+    :Y => 163.17326, 
+    :Z => 128.6231
+  }
+end
+################
+=begin
+Formula: H3N1
+
+Monoisotopic mass :     17.02654
+
+Formula: C1H1O1
+
+Monoisotopic mass :     29.00273
+
+Formula: H2O1
+
+Monoisotopic mass :     18.01056
+
+Formula: H1
+
+Monoisotopic mass :      1.00782
+
+Formula: H2N1
+
+Monoisotopic mass :     16.01872
+
+Formula: C1O1
+
+Monoisotopic mass :     27.99491
+=end

data/spec/fragmenter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Fragmenter do 
+  before :each do 
+    @f = Fragmenter.new
+  end
+  it "generates an appropriate response" do
+    resp = @f.fragment("REALPEPTIDE")
+    resp.should be_a Array
+    resp.size.should == 120
+    resp.include?(157.101111).should be_true
+  end
+  it "handles a single charge state limitation" do 
+    f = Fragmenter.new(:charge_states => false)
+    resp = f.fragment("RYANASTAFK")
+    resp.size.should == 54
+    resp.include?(982.466821).should be_true
+  end
+  it "calculates more ions for the acceptable charge states" do 
+    resp = @f.fragment("RYANASTAFK")
+    resp.size.should == 162
+    resp.include?(491.7334105).should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+
+RSpec.configure do |config|
+  #config.mock_with :rspec
+end
+
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'fragmenter'
+require 'data'
+

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: MS-fragmenter
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Taylor
+autorequire: 
+bindir:
+- bin
+cert_chain: []
+date: 2012-12-10 00:00:00.000000000 Z
+dependencies: []
+description: A peptide sequence fragmenter which will handle graphing and mgf output,
+  as well as command line fragmentation with options
+email: ryanmt@byu.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fragmenter.rb
+- lib/charge_calculator.rb
+- lib/fragmenter/masses.rb
+- spec/spec_helper.rb
+- spec/fragmenter_spec.rb
+homepage: https://github.com/ryanmt/fragmenter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ryanmt's peptide fragmenter
+test_files: []