mspire-simulator 0.1.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Brigham Young University
+Authors: Andrew Noyce, Nozumo Okuda, James Dagliesh, John Prince
+Under the Guidance of: Dr. John Prince
+
+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.rdoc

@@ -0,0 +1,17 @@
+= ms-simulate
+
+Description:
+	Simulates MS runs given amino acid .fasta files. Outputs a .mzML file.
+
+== Install
+  gem install mspire-simulator
+Dependencies:
+  ruby 1.9*
+  weka 3.6.0
+  fftw 3.2.2 - Tested in Linux Mint 12 and Ubuntu Oneiric Ocelot
+== Examples
+ 
+== Copyright
+
+See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mspire-simulator"
+  gem.homepage = "http://dl.dropbox.com/u/42836826/Ms_Sim_Homepage.html"
+  gem.license = "MIT"
+  gem.summary = %Q{Simulates MS1 runs given amino acid FASTA files. Outputs an MZML file.}
+  gem.description = %Q{Simulates MS1 runs given amino acid FASTA files. Outputs an MZML file.
+			Can simulate specific data if given an MZML file containing a single isolated peptide peak.}
+  gem.email = "andrewbnoyce@gmail.com"
+  gem.authors = ["anoyce"]
+  
+  gem.add_dependency "mspire", "0.8.2"
+  gem.add_dependency "rubyvis", "= 0.5.2"
+  gem.add_dependency "nokogiri", "= 1.5.2"
+  gem.add_dependency "ffi", "= 1.0.11"
+  gem.add_dependency "ffi-inliner", "= 0.2.4"
+  gem.add_dependency "fftw3", "= 0.3"
+  gem.add_dependency "distribution", "= 0.7.0"
+  gem.add_dependency "pony", "= 1.4"
+  gem.add_dependency "obo", "= 0.1.0"
+  gem.add_dependency "trollop", "= 1.16.2"
+  
+  gem.executables = ["mspire-simulator"]
+  gem.files.exclude "elution_curvefit.svg"
+  gem.files.exclude "intensity_var_curvefit.svg"
+  gem.files.exclude "lib/pool.rb"
+  gem.files.exclude "mz_var_curvefit.svg"
+  gem.files.exclude "single.mzML"
+  gem.files.exclude "test.mzml"
+  gem.files.exclude "test.mzml_truth.csv"
+  gem.files.exclude "test.mzml_truth.xml"
+  gem.files.exclude "testFiles/*"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/mspire-simulator

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << './lib'
+
+require 'time'
+require 'progress'
+require 'nokogiri'
+require 'mspire/digester'
+require 'mspire/tagged_peak'
+require 'mspire'
+require 'ms/sim_peptide'
+require 'ms/rt/rtgenerator'
+require 'ms/sim_spectra'
+require 'ms/noise'
+require 'ms/mzml_wrapper'
+require 'trollop'
+require 'ms/tr_file_writer'
+require 'ms/isoelectric_calc'
+require 'ms/sim_digester'
+require 'ms/sim_trollop'
+require 'ms/merger'
+
+module MspireSimulator
+@opts = MS::Troll.new.get
+  begin
+
+  @start = Time.now
+
+    one_d = @opts[:one_d]
+    noise = @opts[:noise]
+    truth = @opts[:truth]
+    out_file = @opts[:out_file]
+    email = @opts[:email]
+    
+    if one_d == "true"
+      one_d = true
+      run_time = 300.0
+    else
+      one_d = false
+    end
+    
+    module_function
+    def opts; @opts end
+    
+    #------------------------Digest-----------------------------------------------
+    peptides = []
+    digester = MS::Sim_Digester.new(@opts[:digestor],@opts[:pH])
+    ARGV.each do |file|
+      peptides<<digester.digest(file)
+    end
+    peptides.flatten!.uniq!
+    #-----------------------------------------------------------------------------
+
+
+
+    #------------------------Create Spectrum--------------------------------------
+    spectra = MS::Sim_Spectra.new(peptides, @opts, one_d)
+    data = spectra.data
+    
+    if noise == 'true'
+      noise = spectra.noiseify
+    end
+    #-----------------------------------------------------------------------------
+    
+    
+    
+    #------------------------Merge Overlaps---------------------------------------
+    spectra.spectra = Merger.merge(spectra.spectra,@opts[:overlapRange].to_f)
+    #-----------------------------------------------------------------------------
+    
+    
+    
+    #------------------------Truth Files------------------------------------------
+    if truth != "false"
+      if truth == "xml"
+        MS::Txml_file_writer.write(spectra.features,spectra.spectra,out_file)
+      elsif truth == "csv"
+        MS::Tcsv_file_writer.write(spectra.spectra,data,noise,spectra.features,out_file)
+      end
+    end
+    #-----------------------------------------------------------------------------
+    
+    
+    #-----------------------Merge Finish------------------------------------------
+    spectra.spectra = Merger.compact(spectra.spectra)
+    #-----------------------------------------------------------------------------
+    
+    
+    #-----------------------Clean UP----------------------------------------------
+    spectra.features.each{|fe| fe.delete}
+    peptides.clear
+    #-----------------------------------------------------------------------------
+    
+    
+    
+    #-----------------------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  
+    puts e.backtrace 
+    if digester != nil
+      if File.exists?(digester.digested_file)
+        File.delete(digester.digested_file)
+      end
+    end
+    if spectra != nil
+      spectra.features.each{|fe| fe.delete}
+    end
+    if !peptides.empty?
+      peptides.each{|pep| pep.delete}
+    end
+    puts "Exception - Simulation Failed"
+    
+    system "ruby bin/sim_mail.rb #{email} Exception - Simulation Failed" if email != "nil"
+  else
+    system "ruby bin/sim_mail.rb #{email} Success! - Simulation Complete" if email != "nil"
+  end
+end

data/bin/sim_mail.rb

@@ -0,0 +1,26 @@
+
+require 'pony'
+
+begin
+  address = ARGV[0]
+  msgcount = ARGV.count - 1
+  msgbody = ""
+
+  for i in 1..msgcount
+    msgbody << " #{ARGV[i]}"
+  end
+
+  Pony.mail(:to => address, :via => :smtp, :via_options => {
+    :address              => 'smtp.gmail.com',
+    :port                 => '587',
+    :enable_starttls_auto => true,
+    :user_name            => 'mspire.simulator',
+    :password             => 'chromatography',
+    :authentication       => :plain, 
+    :domain               => "localhost.localdomain" 
+    }, 
+    :subject => 'Mspire-Simulator', :body => msgbody
+  )
+rescue
+  puts "Email function failed. Check email address and internet connection."
+end

data/lib/ms/curvefit/curve_fit_helper.rb

@@ -0,0 +1,152 @@
+require 'time'
+require_relative 'fit_graph'
+
+
+module Enumerable
+  def sum
+    self.inject(0){|accum, i| accum + i }
+  end
+
+  def mean
+    self.sum/self.length.to_f
+  end
+
+  def sample_variance(mean)
+    m = mean
+    sum = self.inject(0){|accum, i| accum +(i-m)**2 }
+    sum/(self.length - 1).to_f
+  end
+
+  def standard_deviation(mean = self.mean)
+    return Math.sqrt(self.sample_variance(mean))
+  end
+end
+
+class GenCurvefit
+  def initialize(pts_in,function = nil,paramsize = nil,mutation_limits = nil,popsize = 0,generations = nil)
+    @pts_in = pts_in
+    @function = function
+    @paramsize = paramsize
+    @mutation_limits = mutation_limits
+    @popsize = popsize
+    @generations = generations
+    @population = []
+    if @popsize != 0 and @paramsize != nil and @mutation_limits != nil and @function != nil
+      init_population
+    end
+  end
+  
+  attr_reader :function, :paramsize, :mutation_limits, :population, :generations, :popsize
+  attr_writer :paramsize, :mutation_limits, :population, :generations, :popsize
+  
+  def init_population
+    @popsize.times do
+      set = []
+      @paramsize.times do |i|
+        limits = @mutation_limits[i]
+        set<<random_float(limits[0],limits[1])
+      end
+      set<<fitness(set,@pts_in)
+      @population<<set
+    end
+  end
+  
+  def set_fit_function(func)
+    @function = func
+  end
+  
+  def mutate(set)
+    index = rand(set.size-1)
+    limits = @mutation_limits[index]
+    set[index] += random_float(limits[0],limits[1])
+  end
+  
+  def self.smoothave(arr)
+    smooth_ave = [nil,nil,nil]
+    queue = []
+    arr.each do |i|
+      queue.push(i)
+      if queue.size > 7
+	queue.shift
+      end
+      smooth_ave<<queue.inject(:+)/queue.size if queue.size == 7
+    end
+    3.times do 
+      smooth_ave<<nil
+    end
+    return smooth_ave
+  end
+  
+  def self.normalize(arr)
+    max = arr.max
+    arr.map!{|i| (i.to_f/max) * 100}
+  end
+  
+  def sort_by_fitness
+    @population.sort_by!{|set| set.last}     
+  end  
+  
+  def random_float(a,b)
+    a = a.to_f
+    b = b.to_f
+    random = rand(2147483647.0) / 2147483647.0
+    diff = b - a
+    r = random * diff
+    return a + r
+  end
+  
+  def rmsd(v,w)
+    n = v.size
+    sum = 0.0
+    n.times{|i| sum += ((v[i][0]-w[i][0])**2.0 + (v[i][1]-w[i][1])**2.0) }
+    return Math.sqrt( (1/n.to_f) * sum )
+  end
+  
+  
+  def fitness(set,pts_in,plot = false)
+    pts = []
+    xs = pts_in.transpose[0]
+    xs.each do |x|
+      fit_pt = function.call(set,x)
+      pts<<[x,fit_pt]
+    end
+    
+    if plot
+      return pts
+    end
+    
+    return rmsd(pts_in,pts)
+  end
+  
+  def fit
+    @start = Time.now
+    @generations.times do |i|
+      Progress.progress("Generation #{i+1}:",((i/@generations.to_f)*100).to_i)
+      #Generate mutations
+      index = rand(@popsize)
+      clone = @population[index].clone
+      mutate(clone)
+      clone[@paramsize] = fitness(clone,@pts_in)
+
+      if(clone.last < @population.last.last)
+        @population[@population.size - (@paramsize-1)] = clone
+      end
+      #Re-sort
+      @population = sort_by_fitness
+
+      #Print best
+      if i == @generations - 1
+        @best = @population.first
+      end
+    end 
+    Progress.progress("Generations Done, printing graph:",100,Time.now-@start)
+    return @best
+  end
+  
+  def plot(file,labels = nil)
+    pts = fitness(@best,@pts_in,true)
+    Fit_plot.plot(@pts_in,pts,file,labels)
+    puts "  Output File: #{file}"
+  end
+  
+end

data/lib/ms/curvefit/fit_graph.rb

@@ -0,0 +1,84 @@
+require 'rubyvis'
+
+class Fit_plot
+  def self.plot(pts,pts2,file,labels = ["",""])
+    xlab = labels[0]
+    ylab = labels[1]
+  
+    w = 600
+    h = 300
+
+    xmin = pts.min_by{|arr| arr[0]}[0]
+    xmax = pts.max_by{|arr| arr[0]}[0]
+    ymin = pts.min_by{|arr| arr[1]}[1]
+    ymax = pts.max_by{|arr| arr[1]}[1]
+
+    line1 = []
+    pts.each do |pt| 
+      line1<<OpenStruct.new({:x=> pt[0], :y=> pt[1]})
+    end
+
+    line2 = []
+    pts2.each do |pt| 
+      line2<<OpenStruct.new({:x=> pt[0], :y=> pt[1]})
+    end
+
+    x = pv.Scale.linear(xmin, xmax).range(0, w)
+    y = pv.Scale.linear(ymin, ymax).range(0, h)
+
+
+    vis = pv.Panel.new()
+      .width(w)
+      .height(h)
+      .bottom(50)
+      .left(40)
+      .right(30)
+      .top(5);
+     
+    vis.add(pv.Dot).
+      stroke_style('blue').
+      data(line1).
+      line_width(2).
+      left(lambda {|d| x.scale(d.x)}).
+      bottom(lambda {|d| y.scale(d.y)}).
+      shape_size(1).
+      anchor("bottom");
+      
+    vis.add(pv.Line).
+      stroke_style('red').
+      data(line2).
+      line_width(2).
+      left(lambda {|d| x.scale(d.x)}).
+      bottom(lambda {|d| y.scale(d.y)}).
+      anchor("bottom");
+      
+    vis.add(pv.Label)
+        .data(x.ticks())
+        .left(lambda {|d| x.scale(d)})
+        .bottom(0)
+        .text_baseline("top")
+        .text_margin(5);
+        
+    vis.add(pv.Label)
+      .bottom(-30)
+      .text(xlab);
+      
+    vis.add(pv.Label)
+      .text_angle(-Math::PI/2.0)
+      .left(-10)
+      .text(ylab);
+
+    vis.add(pv.Rule)
+        .data(y.ticks())
+        .bottom(lambda {|d| y.scale(d)})
+        .stroke_style(lambda {|i|  i!=0 ? pv.color("#ccc") : pv.color("black")})
+      .anchor("right").add(pv.Label)
+      .visible(lambda { (self.index & 1)==0})
+        .text_margin(6);
+        vis.render();
+    
+    file_out = File.open(file,"w")
+    file_out.puts vis.to_svg
+    file_out.close
+  end
+end

data/lib/ms/curvefit/mzml_reader.rb

@@ -0,0 +1,28 @@
+require 'mspire'
+require 'mspire/mzml'
+
+class Mzml_reader
+  def self.get_data(file)
+    mzs_out = []
+    rts_out = []
+    ints_out = []
+    io = File.open(file)
+    mzml = Mspire::Mzml.new(io)
+
+    mzml.each do |spec|
+      next unless spec.ms_level == 1
+      ints = spec.intensities
+      mzs = spec.mzs
+      rt = spec.retention_time
+        
+      if ints.empty?;else
+        ints.each_with_index do |i,j|
+          mzs_out<<mzs[j]
+          rts_out<<rt
+          ints_out<<i
+        end
+      end
+    end
+    return mzs_out,rts_out,ints_out
+  end
+end

data/lib/ms/curvefit.rb

@@ -0,0 +1,120 @@
+
+require 'ms/curvefit/mzml_reader'
+require 'ms/curvefit/curve_fit_helper'
+
+class CurveFit
+  def self.get_parameters(opts)
+    data = Mzml_reader.get_data(opts[:mzml])
+    generations = opts[:generations]
+    
+    @pts_int_var = []
+    @pts_mz_var = []
+    @pts_elut = []
+
+    file = File.open(opts[:mzml],"r")
+
+    mzs_in = data[0]
+    rts_in = data[1]
+    ints_in = data[2]
+
+    ints_in = GenCurvefit.normalize(ints_in)
+    #-----------------------overlapRange--------------------------------------------
+    mean = mzs_in.inject(:+)/mzs_in.size
+    opts[:overlapRange] = (mzs_in.sample_variance(mean)*10**6)/4
+    #-------------------------------------------------------------------------------
+    
+    
+    #----------------------create points/curve to fit elution-----------------------
+    ints_in.each_with_index do |s,i|
+      @pts_elut<<[rts_in[i],s]
+    end
+    opts[:sampling_rate] = rts_in.size/(rts_in.max - rts_in.min)
+
+    a_fit = GenCurvefit.new(@pts_elut)
+    a_fit.set_fit_function(lambda{|a,i| 100.0*Math.exp(-(rts_in.index(i)-a[2])**2/((a[1]*rts_in.index(i)+a[0])**2))})
+    a_fit.mutation_limits = [[-5,5],[-1,1],[-rts_in.size/2,rts_in.size/2]]
+    a_fit.popsize = 10
+    a_fit.paramsize = 3
+    a_fit.init_population
+    a_fit.generations = generations
+
+    best = a_fit.fit
+    opts[:front] = best[0]
+    opts[:tail] = best[1]
+    opts[:mu] = best[2]
+    #puts "RMSD = #{best[3]}"
+    labels = ["retention time","normalized intensity"]
+    a_fit.plot("elution_curvefit.svg",labels)
+    #-------------------------------------------------------------------------------
+    
+    
+    #-----------------create points/curve to fit m/z variance-----------------------
+    wobs = []
+    mean = mzs_in.inject(:+)/mzs_in.size
+    mzs_in.each do |mz|
+      wobs<<(mean-mz).abs
+    end
+
+    ints_in.length.times do |d|
+      if d >= 3
+        sd = wobs[d-3..d].standard_deviation
+        @pts_mz_var<<[ints_in[d],sd]
+      end
+    end
+
+    b_fit = GenCurvefit.new(@pts_mz_var)
+    b_fit.set_fit_function(lambda{|a,i| a[0]*i**a[1]})
+    b_fit.mutation_limits = [[-1,1],[-1,1]]
+    b_fit.popsize = 10
+    b_fit.paramsize = 2
+    b_fit.init_population
+    b_fit.generations = generations
+
+    best = b_fit.fit
+    opts[:wobA] = best[0]
+    opts[:wobB] = best[1]
+    #puts "RMSD = #{best[2]}"
+    labels = ["normalized intensity","m/z variance"]
+    b_fit.plot("mz_var_curvefit.svg",labels)
+    #-------------------------------------------------------------------------------
+    
+    #--------------------create points/curve to fit intensity variance--------------
+    smooth_ave = GenCurvefit.smoothave(ints_in)
+
+    diff = []
+    smooth_ave.each_with_index do |s,i|
+      if s == nil
+        diff<<0
+      else
+        diff<<(s-ints_in[i]).abs
+      end
+    end
+
+
+    ints_in.each_with_index do |i,d|
+      if d >= 3
+        sd = diff[d-3..d].standard_deviation
+        @pts_int_var<<[i,sd]
+      end
+    end
+
+    c_fit = GenCurvefit.new(@pts_int_var)
+    c_fit.set_fit_function(lambda{|a,i| a[0]*(1-Math.exp(-a[2]*i))+a[1]})
+    c_fit.mutation_limits = [[-20,20],[-0.5,0.5],[-0.5,0.5]]
+    c_fit.popsize = 10
+    c_fit.paramsize = 3
+    c_fit.init_population
+    c_fit.generations = generations
+
+    best = c_fit.fit
+    opts[:jagA] = best[0]
+    opts[:jagC] = best[1]
+    opts[:jagB] = best[2]
+    #puts "RMSD = #{best[3]}"
+    labels = ["normalized intensity","intensity variance"]
+    c_fit.plot("intensity_var_curvefit.svg",labels)
+    #-------------------------------------------------------------------------------
+    
+    return opts
+  end
+end