mspire-simulator 0.2.1 → 0.3.0

data/README.rdoc

@@ -8,11 +8,14 @@ Description:
 Dependencies:
   ruby 1.9*
   weka 3.6.0 - May need to add to CLASSPATH see: http://weka.wikispaces.com/CLASSPATH+problems
-  fftw 3.2.2 - Tested in Linux Mint 12 and Ubuntu Oneiric Ocelot
+  fftw 3.2.2 - Tested in Linux Mint 12 and Ubuntu Oneiric Ocelot and Ubuntu 12.04
+  SQLite3 3.6.16 or newer (Note: install this first if needed)
 == Examples
-The simplest way to run mspire-simulator is to give it a MZML file 
-with a single centroided elution profile from which, the simulator 
+
+The simplest way to run mspire-simulator is to give it an mzML file 
+with a single centroided elution profile from which the simulator 
 can extract needed parameters including:
+
 - Elution parameters: front, tail, and mu
 - Overlap range (for merging signals)
 - Sampling rate
@@ -29,9 +32,9 @@ To see all the available options:
   
     $ mspire-simulator --help
     
-    
 === Charge State Calculator
-  $ ruby lib/ms/isoelectric_calc.rb --ph 2 --distribution DRVYIHPFHL DRVYIHPF RVYIHPF VYIHPF 
+
+    $ ruby lib/ms/isoelectric_calc.rb --ph 2 --distribution DRVYIHPFHL DRVYIHPF RVYIHPF VYIHPF 
 
 will return: 
 
@@ -46,13 +49,13 @@ VYIHPF @ pH 2.0:	+1, 40.341305; +2, 59.658695
 To see all the available options: 
     $ ruby lib/ms/isoelectric_calc.rb --help
 
-
-    
 == TODO
+
 Because of the many options and parameters to specify we will be moving
 to a .init file format with a .init file editor.
 
-Other improvments to mspire simulator are also pending.
+Other improvments to mspire-simulator are also pending.
+
 == Copyright
 
 See LICENSE.txt for further details.

data/Rakefile

@@ -13,7 +13,7 @@ Jeweler::Tasks.new do |gem|
   gem.email = "andrewbnoyce@gmail.com"
   gem.authors = ["anoyce"]
   
-  gem.add_dependency "mspire", "0.8.2"
+  gem.add_dependency "mspire", "0.8.5"
   gem.add_dependency "rubyvis", "= 0.5.2"
   gem.add_dependency "nokogiri", "= 1.5.2"
   gem.add_dependency "ffi", "= 1.0.11"
@@ -24,6 +24,7 @@ Jeweler::Tasks.new do |gem|
   gem.add_dependency "obo", "= 0.1.0"
   gem.add_dependency "trollop", "= 1.16.2"
   gem.add_dependency "MS-fragmenter", "= 0.0.2"
+  gem.add_dependency "sqlite3", "= 1.3.6"
   
   gem.executables = ["mspire-simulator","sim_mail"]
   gem.files.exclude "elution_curvefit.svg"

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/bin/mspire-simulator

@@ -1,7 +1,12 @@
 #!/usr/bin/env ruby
+#SQLite version = 3.7.13
+#sudo aptitude install sqlite3
+#sudo aptitude install libsqlite3-dev
+#gem install sqlite3
 $LOAD_PATH << './lib'
 
 require 'time'
+require 'sqlite3'
 require 'progress'
 require 'nokogiri'
 require 'mspire/digester'
@@ -18,6 +23,7 @@ require 'ms/isoelectric_calc'
 require 'ms/sim_digester'
 require 'ms/sim_trollop'
 require 'ms/merger'
+require 'ms/sim_modifications'
 
 
 
@@ -46,70 +52,71 @@ module MspireSimulator
 
     SampleLoad = 1.0 # Instrument dependent scaling, for an Orbitrap, assumed to be 1 ug 
     # TODO define an option for sample loading, and a scaling function to define the peak intensities
-    
-    #------------------------Digest-----------------------------------------------
+    database = nil
+    if @opts[:memory] == "true"
+      database = ":memory:" #can be :memory: stored
+    else
+      if @opts[:databaseName] == "peptides_[Time.now.sec]"
+        database = "peptides_#{Time.now.sec}.sqlite3" 
+      else
+        database = "#{@opts[:databaseName]}.sqlite3"
+      end
+    end
+    #
+    db = SQLite3::Database.new(database)
+    db.transaction
+    db.execute "CREATE TABLE IF NOT EXISTS peptides(Id INTEGER PRIMARY KEY, seq TEXT, mass REAL, charge INTEGER, mono_mz REAL, p_rt REAL, p_rt_index REAL, p_int REAL, abu REAL, sx REAL, rt_a INTEGER, rt_b INTEGER, prot_id INTEGER)"
+    db.execute "CREATE TABLE IF NOT EXISTS aac(Id INTEGER PRIMARY KEY, A INTEGER,R INTEGER,N INTEGER,D INTEGER,B INTEGER,C INTEGER,E INTEGER,Q INTEGER,Z INTEGER,G INTEGER,H INTEGER,I INTEGER,L INTEGER,K INTEGER,M INTEGER,F INTEGER,P INTEGER,S INTEGER,T INTEGER,W INTEGER,Y INTEGER,V INTEGER,J INTEGER, place_holder REAL)"
+    db.execute "CREATE TABLE IF NOT EXISTS core_spec(pep_id INTEGER PRIMARY KEY,mzs TEXT, ints TEXT)"
+    #
+    
+    #------------------------Digest-&-Modifications-------------------------------
     peptides = []
-    digester = MS::Sim_Digester.new(@opts[:digestor],@opts[:pH])
+    digester = MS::Sim_Digester.new(@opts,db)
     ARGV.each do |file|
-      peptides<<digester.digest(file)
+      digester.digest(file)
     end
-    peptides.flatten!.uniq!
     #-----------------------------------------------------------------------------
 
 
 
     #------------------------Create Spectrum--------------------------------------
-    spectra = MS::Sim_Spectra.new(peptides, @opts, one_d)
-    data = spectra.data
+    spectra = MS::Sim_Spectra.new(@opts, one_d,db)
     
     if noise == 'true'
-      noise = spectra.noiseify
+      noise = spectra.noiseify(db)
     end
     #-----------------------------------------------------------------------------
     
     
     
     #------------------------Merge Overlaps---------------------------------------
-    spectra.spectra = Merger.merge(spectra.spectra,@opts[:overlapRange].to_f)
+    Merger.merge(@opts[:overlapRange].to_f,db)
     #-----------------------------------------------------------------------------
     
     
     
+    #-----------------------MZML--------------------------------------------------
+    mzml = Mzml_Wrapper.new(db,@opts)
+    prog = Progress.new("Writing to mzml file...")
+    mzml.to_xml(out_file)
+    prog.finish!
+    #-----------------------------------------------------------------------------
+
+
+
     #------------------------Truth Files------------------------------------------
     if truth != "false"
       if truth == "xml"
-        MS::Txml_file_writer.write(spectra.features,spectra.spectra,out_file)
+        MS::Txml_file_writer.write(db,out_file,@opts)
       elsif truth == "csv"
-        MS::Tcsv_file_writer.write(spectra.spectra,data,noise,spectra.features,out_file)
+        MS::Tcsv_file_writer.write(db,out_file,@opts)
+      elsif truth == "xml_csv" or truth == "csv_xml"
+        MS::Txml_file_writer.write(db,out_file,@opts)
+        MS::Tcsv_file_writer.write(db,out_file,@opts)
       end
     end
     #-----------------------------------------------------------------------------
-    
-    
-    
-    #-----------------------Merge Finish------------------------------------------
-    spectra.spectra = Merger.compact(spectra.spectra)
-    #-----------------------------------------------------------------------------
-    
- 
-    
-    #-----------------------Clean UP----------------------------------------------
-    spectra.features.each{|fe| fe.delete}
-    peptides.clear
-    digester.clean
-    #-----------------------------------------------------------------------------
-    
-    
-    
-    #-----------------------MZML--------------------------------------------------
-    data = spectra.spectra
-    mzml = Mzml_Wrapper.new(data)
-    puts "Writing to file..."
-    mzml.to_xml(out_file)
-    puts "Done."
-    #-----------------------------------------------------------------------------
-
-
 
   rescue Exception => e  #Clean up if exception 
     puts e.message  
@@ -118,18 +125,12 @@ module MspireSimulator
       if File.exists?(digester.digested_file)
         File.delete(digester.digested_file)
       end
-      digester.clean
-    end
-    if spectra != nil
-      spectra.features.each{|fe| fe.delete}
-    end
-    if !peptides.empty?
-      peptides.each{|pep| pep.delete}
     end
+    system "rm #{database}"
     puts "Exception - Simulation Failed"
-    
-    system "sim_mail #{email} Exception - Simulation Failed" if email != "nil"
-  else
-    system "sim_mail #{email} Success! - Simulation Complete" if email != "nil"
+  ensure
+    system "sim_mail #{email} Simulation Complete" if email != "nil"
+    db.commit
+    db.close if db
   end
 end

data/lib/ms/merger.rb

@@ -34,81 +34,42 @@ class Merger
     return a/b
   end
 
-  def self.merge(spectra,half_range)
-    new_data = {}
+  def self.merge(half_range,db)
+    prog = Progress.new("Merging Overlaps:")
+    db.execute "CREATE TABLE IF NOT EXISTS merged(merge_id INTEGER PRIMARY KEY, merged_vals TEXT, a_vals TEXT, b_vals TEXT)"
+    spectra = db.execute "SELECT * FROM spectra"
+    spectra = spectra.group_by{|spec| spec[2]}
     total = spectra.size
+    merge_id = 0
     k = 0
-    prog = Progress.new("Merging Overlaps:")
-    spectra.each do |rt,val|
+    spectra.each do |rt,peaks|
       if k.even?
         num = (((k/total)*100).to_i)
         prog.update(num)
       end
-      peaks = val.transpose
-      peaks.sort_by!{|a| a[0]} #mz
-      peaks = peaks.transpose
-      mzs = peaks[0]
-      ints = peaks[1]
+      peaks.sort_by!{|a| a[2]} #mz
+      peaks_t = peaks.transpose
+      pep_ids = peaks_t[1]
+      cent_ids = peaks_t[0]
+      mzs = peaks_t[3]
+      ints = peaks_t[4]
       mzs.each_with_index do |mz,i|
-        next if mz.class == Hash
         o_mz = mz
-        mz = mz.keys[0][0] if mz.class == Hash
         range = (mz..mz+half_range)
         if range.include?(mzs[i+1])
           metaA_mz = [o_mz, mzs[i+1]]
           meta_int = [ints[i],ints[i+1]]
-          sum = meta_int.flatten.inject(:+).to_f
-          i1 = ints[i]
-          i1 = ints[i].flatten.inject(:+) if ints[i].class == Array
-          frac1 = (i1/sum) * 100
-          frac2 = (ints[i+1]/sum) * 100
-          metaB_mz = {[w_avg(metaA_mz,meta_int),frac1,frac2] => metaA_mz}
-
-          mzs[i] = nil; mzs[i+1] = metaB_mz
-          ints[i] = nil; ints[i+1] = meta_int
-        end
-      end
-      spec = [mzs.compact,ints.compact]
-      spec.ms_level = val.ms_level
-      spec.ms2 = val.ms2
-      new_data[rt] = spec
-      k += 1
-    end
-    prog.finish!
-    return new_data
-  end
-
-  def self.compact(spectra)
-    @start = Time.now
-    total = spectra.size
-    k = 0
-    num = 0
-    prog = Progress.new("Merge Finishing:")
-    step = total/100.0
-    spectra.each do |rt,val|
-      if k > step * (num + 1)
-        num = (((k/total)*100).to_i)
-        prog.update(num)
-      end
-      mzs = val[0]
-      ints = val[1]
-      mzs.each_with_index do |m,i|
-        if m.class == Hash
-          mzs[i] = m.keys[0][0]
-          ints[i] = ints[i].flatten.inject(:+)
+          sum = ints[i] + ints[i+1]
+          new_mz = w_avg(metaA_mz,meta_int)
+          db.execute "DELETE FROM spectra WHERE cent_id=#{cent_ids[i]}"
+          db.execute "DELETE FROM spectra WHERE cent_id=#{cent_ids[i+1]}"
+          db.execute "INSERT INTO spectra VALUES(#{cent_ids[i]},#{pep_ids[i]},#{rt},#{new_mz},#{sum},#{merge_id})"
+          db.execute "INSERT INTO merged VALUES(#{merge_id}, '#{cent_ids[i]},#{pep_ids[i]},#{rt},#{new_mz},#{sum}', '#{peaks[i]}', '#{peaks[i+1]}')"
+          merge_id += 1
         end
       end
-      spec = [mzs,ints]
-      spec.ms_level = val.ms_level
-      spec.ms2 = val.ms2
-      spectra[rt] = spec
       k += 1
     end
     prog.finish!
-    return spectra
   end
 end
-
-#test
-#data = {1 => [[1.0,1.5,1.7,3.0,4.0,5.0,6.0,7.0,8.0,9.0],[10,9,8,7,6,5,4,3,2,1]], 2 => [[1,2,3,4,5,6,7,8,9],[9,8,7,6,5,4,3,2,1]]}
-#p Merger.merge(data,0.5)

data/lib/ms/mzml_wrapper.rb

@@ -5,35 +5,48 @@ require 'mspire/mzml'
 
 class Mzml_Wrapper
 
-  def initialize(spectra)
+  def initialize(db,opts)
+    prog = Progress.new("Converting to mzml:")
     #spectra is a Hash rt=>[[mzs],[ints]]
-    ms2_count = 0
+    db.execute "CREATE TABLE IF NOT EXISTS ms2(ms2_id INTEGER PRIMARY KEY,cent_id INTEGER,pep_id INTEGER,rt REAL,mzs TEXT,ints TEXT)" if opts[:ms2] == "true"
+    sampling_rate = opts[:sampling_rate]
+    noise_max = opts[:noiseMaxInt]
     count = 0.0
     scan_number = 1
     specs = []
-    prog = Progress.new("Converting to mzml:")
     num = 0
+    spectra = db.execute "SELECT * FROM spectra"
     total = spectra.size
+    spectra_g = spectra.group_by{|spec| spec[2]} #rt
     step = total/100
     spec_id = nil
-    t_rt = 0
-    spectra.sort.map do |rt,data|
+    spectra_g.sort.map do |rt,data|
       if count > step * (num + 1)
         num = (((count/total)*100).to_i)
         prog.update(num)
       end
-      if t_rt > rt
-	puts "OUT of ORDER"
-      end
-      t_rt = rt
+      data_t = data.transpose
+      mzs = data_t[3]
+      ints = data_t[4]
 
-      ms_level = data.ms_level # method added to array class
+      #grab top 2 centroids for ms2
+      ms2s = []
+      if opts[:ms2] == "true"
+        top2 = ints.sort[-opts[:ms2s]..-1]
+        top2.each do |top|
+          if top > noise_max + 1000.0
+            cent = data[ints.index(top)]
+            ms2s<<cent if cent[1] != nil
+          end
+        end
+      end
+      
 
       spc = Mspire::Mzml::Spectrum.new("scan=#{scan_number}") do |spec|
         spec.describe_many!(['MS:1000127', ['MS:1000511', 1]]) 
         spec.data_arrays = [
-          Mspire::Mzml::DataArray.new(data[0]).describe!('MS:1000514'),  
-          Mspire::Mzml::DataArray.new(data[1]).describe!('MS:1000515')   
+          Mspire::Mzml::DataArray.new(mzs).describe!('MS:1000514'),  
+          Mspire::Mzml::DataArray.new(ints).describe!('MS:1000515')   
         ]
         spec.scan_list = Mspire::Mzml::ScanList.new do |sl|
           scan = Mspire::Mzml::Scan.new do |scan|
@@ -43,36 +56,44 @@ class Mzml_Wrapper
         end
       end
       specs<<spc
-      if ms_level == 2
+      if !ms2s.empty?
         #[rt,[mzs],[ints]]
-        ms2 = data.ms2
-        ms2.each do |data|
-          ms2_count += 1
-          scan_number += 1
-          spc2 = Mspire::Mzml::Spectrum.new("scan=#{scan_number}") do |spec|
-            spec.describe_many!(['MS:1000127', ['MS:1000511', 2]]) 
-            spec.data_arrays = [
-              Mspire::Mzml::DataArray.new(data[1]).describe!('MS:1000514'),  
-              Mspire::Mzml::DataArray.new(data[2]).describe!('MS:1000515')   
-            ]
-            spec.scan_list = Mspire::Mzml::ScanList.new do |sl|
-              scan = Mspire::Mzml::Scan.new do |scan|
-                scan.describe! 'MS:1000016', data[0], 'UO:0000010'
+        ms2s.each do |cent|
+          pep = db.execute "SELECT seq,charge FROM peptides WHERE Id=#{cent[1]}"
+          seq = pep[0][0]
+          if seq.size > 1
+            charge = pep[0][1]
+            ms2_mzs = MS::Fragmenter.new.fragment(seq)
+            ms2_ints = Array.new(ms2_mzs.size,500.to_f)
+            rt = cent[2] + RThelper.RandomFloat(0.01,sampling_rate - 0.1)
+            db.execute "INSERT INTO ms2(cent_id,pep_id,rt,mzs,ints) VALUES(#{cent[0]},#{cent[1]},#{rt},'#{ms2_mzs}','#{ms2_ints}')"
+
+            scan_number += 1
+            spc2 = Mspire::Mzml::Spectrum.new("scan=#{scan_number}") do |spec|
+              spec.describe_many!(['MS:1000127', ['MS:1000511', 2]]) 
+              spec.data_arrays = [
+                Mspire::Mzml::DataArray.new(ms2_mzs).describe!('MS:1000514'),  
+                Mspire::Mzml::DataArray.new(ms2_ints).describe!('MS:1000515')   
+              ]
+              spec.scan_list = Mspire::Mzml::ScanList.new do |sl|
+                scan = Mspire::Mzml::Scan.new do |scan|
+                  scan.describe! 'MS:1000016', rt, 'UO:0000010'
+                end
+                sl << scan
               end
-              sl << scan
+              precursor = Mspire::Mzml::Precursor.new( spc.id )
+              si = Mspire::Mzml::SelectedIon.new
+              # the selected ion m/z:
+              si.describe! "MS:1000744", cent[3] #pre_mz
+              # the selected ion charge state
+              si.describe! "MS:1000041", charge #pre_charge
+              # the selected ion intensity
+              si.describe! "MS:1000042", cent[4] #pre_int
+              precursor.selected_ions = [si]
+              spec.precursors = [precursor]
             end
-            precursor = Mspire::Mzml::Precursor.new( spc.id )
-            si = Mspire::Mzml::SelectedIon.new
-            # the selected ion m/z:
-            si.describe! "MS:1000744", data.pre_mz
-            # the selected ion charge state
-            si.describe! "MS:1000041", data.pre_charge
-            # the selected ion intensity
-            si.describe! "MS:1000042", data.pre_int
-            precursor.selected_ions = [si]
-            spec.precursors = [precursor]
           end
-          specs<<spc2
+          specs<<spc2 if seq.size > 1
         end
       end
       count += 1
@@ -92,7 +113,7 @@ class Mzml_Wrapper
       mzml.instrument_configurations << default_instrument_config
       software = Mspire::Mzml::Software.new
       mzml.software_list << software
-      default_data_processing = Mspire::Mzml::DataProcessing.new("did_nothing")
+      default_data_processing = Mspire::Mzml::DataProcessing.new("simulator options=#{opts}")
       mzml.data_processing_list << default_data_processing
       mzml.run = Mspire::Mzml::Run.new("simulated_run", default_instrument_config) do |run|
         spectrum_list = Mspire::Mzml::SpectrumList.new(default_data_processing, specs)
@@ -100,7 +121,6 @@ class Mzml_Wrapper
       end
     end
     prog.finish!
-    puts "ms2 written = #{ms2_count}"
     return @mzml
   end