mspire-simulator 0.1.0

data/lib/ms/sim_feature.rb

@@ -0,0 +1,175 @@
+
+require 'time'
+require 'distribution'
+require 'ms/sim_peptide'
+require 'ms/rt/rt_helper'
+require 'ms/tr_file_writer'
+
+module MS
+  class Sim_Feature 
+    def initialize(peptides,opts,one_d)
+      
+      @start = Time.now
+      @features = []
+      @data = {}
+      @max_int = 0.0
+      @one_d = one_d
+      @max_time = Sim_Spectra.r_times.max
+      @opts = opts
+      
+      
+      #------------------Each_Peptide_=>_Feature----------------------
+      peptides.each_with_index do |pep,ind|
+	Progress.progress("Generating features:",(((ind+1)/peptides.size.to_f)*100).to_i)	
+	
+	feature = getInts(pep)
+
+	@features<<feature
+      end
+      Progress.progress("Generating features:",100,Time.now-@start)
+      puts ""
+      @start = Time.now
+      #---------------------------------------------------------------
+      
+      
+      
+      #-----------------Transform_to_spectra_data_for_mzml------------
+      # rt => [[mzs],[ints]]
+      @features.each_with_index do |fe,k|
+	Progress.progress("Populating structure for mzml:",((k/@features.size.to_f)*100).to_i)
+	
+	fe_ints = fe.ints
+	fe_mzs = fe.mzs
+	
+	fe.rts.each_with_index do |rt,i|
+	  rt_mzs = []
+	  rt_ints = []
+	  
+	  fe.core_mzs.size.times do |j| 
+	    mz,int = [ fe_mzs[j][i], fe_ints[j][i] ]
+	    if int == nil
+	      int = 0.0
+	    end
+	    if int > 0.9
+	      rt_mzs<<mz
+	      rt_ints<<int
+	    end
+	  end
+	  
+	  if rt_mzs.include?(nil) or rt_mzs.empty?; else
+	    if @data.key?(rt)
+	      mzs,ints = @data[rt]
+	      @data[rt][0] = mzs + rt_mzs
+	      @data[rt][1] = ints + rt_ints
+	    else
+	      @data[rt] = [rt_mzs, rt_ints]
+	    end
+	  end
+	end
+      end
+      Progress.progress("Populating structure for mzml:",100,Time.now-@start)
+      puts ""
+      
+      #---------------------------------------------------------------
+      
+    end
+    
+    attr_reader :data, :features
+    attr_writer :data, :features
+    
+    # Intensities are shaped in the rt direction by a gaussian with 
+    # a dynamic standard deviation.
+    # They are also shaped in the m/z direction 
+    # by a simple gaussian curve (see 'factor' below). 
+    #
+    def getInts(pep)
+      
+      p_int = pep.p_int + RThelper.RandomFloat(-5,2)
+      if p_int > 10
+	p_int -= 10
+      end
+      predicted_int = (p_int * 10**-1) * 14183000.0
+      relative_ints = pep.core_ints
+      avg = pep.p_rt
+      
+      sampling_rate = @opts[:sampling_rate].to_f
+      tail = @opts[:tail].to_f
+      front = @opts[:front].to_f
+      mu = @opts[:mu].to_f
+      
+      index = 0
+      
+      shuff = RThelper.RandomFloat(0.05,1.0)
+      pep.core_mzs.each do |mzmu|
+
+	fin_mzs = []
+	fin_ints = []
+	t_index = 1
+	
+	relative_abundances_int = relative_ints[index]
+
+	pep.rts.each_with_index do |rt,i| 
+	  percent_time = rt/@max_time
+	  length_factor = 1.0#-3.96 * percent_time**2 + 3.96 * percent_time + 0.01
+	  length_factor_tail = 1.0#-7.96 * percent_time**2 + 7.96 * percent_time + 0.01
+	  
+	
+	  if !@one_d
+	    #-------------Tailing-------------------------
+	    shape = (tail * length_factor)* t_index + (front * length_factor_tail)
+	    fin_ints << (RThelper.gaussian(t_index,mu,shape,100.0)) 
+	    t_index += 1
+	    #---------------------------------------------
+	    
+	  else
+	    #-----------Random 1d data--------------------
+	    fin_ints<<(relative_abundances_int * ints_factor) * shuff
+	    #---------------------------------------------
+	  end
+	  
+	  if fin_ints[i] < 0.01
+	    fin_ints[i] = RThelper.RandomFloat(0.001,0.4)
+	  end
+
+=begin
+	  if !@one_d
+	    #-------------M/Z Peak shape (Profile?)-------
+	    fraction = RThelper.gaussian(fin_mzs[i],mzmu,0.05,1)
+	    factor = fraction/1.0
+	    fin_ints[i] = fin_ints[i] * factor
+	    #---------------------------------------------
+	  end
+=end	  
+	  #-------------Jagged-ness---------------------
+	  sd = (@opts[:jagA] * (1-Math.exp(-(@opts[:jagC]) * fin_ints[i])) + @opts[:jagB])/2
+	  diff = (Distribution::Normal.rng(0,sd).call)
+	  fin_ints[i] = fin_ints[i] + diff
+	  #---------------------------------------------
+	  
+	  
+	  #-------------mz wobble-----------------------
+	  y = fin_ints[i]
+	  if y > 0
+	    wobble_int = @opts[:wobA]*y**(@opts[:wobB])
+	    wobble_mz = Distribution::Normal.rng(mzmu,wobble_int).call
+	    if wobble_mz < 0
+	      wobble_mz = 0.01
+	    end
+
+	    fin_mzs<<wobble_mz
+	  end
+	  #---------------------------------------------
+	  
+  
+	  fin_ints[i] = fin_ints[i]*(predicted_int*(relative_abundances_int*10**-2))
+	end
+	
+	pep.insert_ints(fin_ints)
+	pep.insert_mzs(fin_mzs)
+	
+	index += 1
+      end
+      return pep
+    end
+  end
+end

data/lib/ms/sim_peptide.rb

@@ -0,0 +1,182 @@
+
+require 'mspire/isotope/distribution'
+
+module MS
+  class Peptide
+    def initialize(sequence, charge)
+      @p_rt = 0
+      @p_int = 0
+      @rts = []
+      @charge = charge #this is saved in the file name as well
+      
+      spec = calcSpectrum(sequence, @charge)
+      
+      @core_ints = spec.intensities.clone
+      @core_mzs = spec.mzs.clone
+      @mzs_file = ".m/#{sequence[0]}/#{sequence[0...15]}_#{charge}"
+      @ints_file = ".i/#{sequence[0]}/#{sequence[0...15]}_#{charge}"
+      file = File.open(@mzs_file, "w")
+      file.puts(sequence)
+      file.close
+      @mono_mz = spec.mzs[spec.intensities.index(spec.intensities.max)]
+      @mass = @mono_mz * @charge
+      #U,O,X ???
+      amino_acids = ['A','R','N','D','B','C','E','Q','Z','G','H','I',
+		     'L','K','M','F','P','S','T','W','Y','V','J']
+      @aa_counts = amino_acids.map do |aa|
+	sequence.count(aa)
+      end
+      @aa_counts<<0.0
+    end
+    
+    attr_reader :mass, :charge, :mono_mz, :core_mzs, :p_rt, :p_int, :core_ints, :hydro, :pi, :aa_counts, :p_rt_i
+    attr_writer :mass, :charge, :mono_mz, :core_mzs, :p_rt, :p_int, :core_ints, :hydro, :pi, :aa_counts, :p_rt_i
+    
+    def to_s
+      file = File.open(@mzs_file,"r")
+      seq = file.gets.chomp
+      file.close
+      "Peptide: #{seq}"
+    end
+    
+    def sequence
+      file = File.open(@mzs_file,"r")
+      seq = file.gets.chomp
+      file.close
+      seq
+    end
+    
+    #---------------------------------------------------------------------------
+    def ints
+      file = File.open(@ints_file, "r")
+      line = file.gets.chomp.split(/;/)
+      file.close
+      ints = []
+      line.each do |iso|
+	ints<<iso.chomp.split(/,/).map!{|fl| fl.to_f}
+      end
+      return ints
+    end
+    
+    def insert_ints(arr)
+      file = File.open(@ints_file, "a")
+      arr.each do |val|
+	file.print("#{val},")
+      end
+      file.print(";")
+      file.close
+    end
+    
+    def mzs
+      file = File.open(@mzs_file, "r")
+      line = file.gets
+      line = file.gets.chomp.split(/;/)
+      file.close
+      mzs = []
+      line.each do |iso|
+	mzs<<iso.chomp.split(/,/).map!{|fl| fl.to_f}
+      end
+      return mzs
+    end
+    
+    def insert_mzs(arr)
+      file = File.open(@mzs_file, "a")
+      arr.each do |val|
+	file.print("#{val},")
+      end
+      file.print(";")
+      file.close
+    end
+    
+    def rts
+      return Sim_Spectra::r_times[@rts[0]..@rts[1]]
+    end
+    
+    def set_rts(a,b)
+      @rts = [a,b]
+    end
+    
+    def delete
+      if File.exists?(@mzs_file)
+	File.delete(@mzs_file)
+      end
+      if File.exists?(@ints_file)
+	File.delete(@ints_file)
+      end
+    end
+    #---------------------------------------------------------------------------
+    
+    # Calculates theoretical specturm
+    #
+    def calcSpectrum(seq, charge)
+      #isotope.rb from Dr. Prince
+      atoms = countAtoms(seq)
+      
+      var = ""
+      var<<"O"
+      var<<atoms[0].to_s
+      var<<"N"
+      var<<atoms[1].to_s
+      var<<"C"
+      var<<atoms[2].to_s
+      var<<"H"
+      var<<atoms[3].to_s
+      var<<"S"
+      var<<atoms[4].to_s
+      var<<"P"
+      var<<atoms[5].to_s
+      var<<"Se"
+      var<<atoms[6].to_s
+      
+      mf = Mspire::MolecularFormula.from_string(var, charge)
+      spec = Mspire::Isotope::Distribution.spectrum(mf, :max, 0.001)
+
+      spec.intensities.map!{|i| i = i*100.0}
+
+      return spec
+    end
+    
+      
+    # Counts the number of each atom in the peptide sequence.
+    #
+    def countAtoms(seq)
+      o = 0
+      n = 0
+      c = 0
+      h = 0
+      s = 0
+      p = 0
+      se = 0
+      seq.each_char do |aa|
+      
+	#poly amino acids
+	#"X" is for any (I exclude uncommon "U" and "O")
+	if aa == "X"
+	  aas = Mspire::Isotope::AA::ATOM_COUNTS.keys[0..19]
+	  aa = aas[rand(20)]
+	#"B" is "N" or "D"
+	elsif aa == "B"
+	  aas = ["N","D"]
+	  aa = aas[rand(2)]
+	#"Z" is "Q" or "E"
+	elsif aa == "Z"
+	  aas = ["Q","E"]
+	  aa = aas[rand(2)]
+	end
+	
+	if aa !~ /A|R|N|D|C|E|Q|G|H|I|L|K|M|F|P|S|T|W|Y|V|U|O/
+	  puts "No amino acid match for #{aa}"
+	else
+	  o = o + Mspire::Isotope::AA::ATOM_COUNTS[aa][:o]
+	  n = n + Mspire::Isotope::AA::ATOM_COUNTS[aa][:n]
+	  c = c + Mspire::Isotope::AA::ATOM_COUNTS[aa][:c]
+	  h = h + Mspire::Isotope::AA::ATOM_COUNTS[aa][:h]
+	  s = s + Mspire::Isotope::AA::ATOM_COUNTS[aa][:s]
+	  p = p + Mspire::Isotope::AA::ATOM_COUNTS[aa][:p]
+	  se = se + Mspire::Isotope::AA::ATOM_COUNTS[aa][:se]
+	end
+      end
+      return (o + 1),n,c,(h + 2) ,s,p,se
+    end
+  end
+end

data/lib/ms/sim_spectra.rb

@@ -0,0 +1,70 @@
+$LOAD_PATH << './lib'
+require 'ms/rt/rt_helper'
+require 'ms/noise'
+require 'ms/rt/rtgenerator'
+require 'ms/sim_feature'
+
+module MS
+  class Sim_Spectra
+    def initialize(peptides,opts,one_d = false)
+      @density = opts[:noise_density]
+      @data
+      @max_mz
+			sampling_rate = opts[:sampling_rate]
+			run_time = opts[:run_time]
+			drop_percentage = opts[:dropout_percentage]
+      #RTS
+      var = 0.1/(sampling_rate*2)
+      @@r_times = []
+      num_of_spec = sampling_rate*run_time
+      spec_time = 1/sampling_rate
+      num_of_spec.to_i.times do
+        @@r_times<<spec_time+RThelper.RandomFloat(-var,var)
+        spec_time = spec_time + (1/sampling_rate)
+      end
+      @@r_times = MS::Noise.spec_drops(drop_percentage)
+      
+      pre_features = MS::Rtgenerator.generateRT(peptides,one_d)
+      
+      #Features
+      features_o = MS::Sim_Feature.new(pre_features,opts,one_d)
+      @features = features_o.features
+      @data = features_o.data
+      @max_mz = @data.max_by{|key,val| if val != nil;val[0].max;else;0;end}[1][0].max
+      @spectra = @data.clone
+      
+      @noise = nil
+      
+    end
+    
+    def noiseify
+      @noise = MS::Noise.noiseify(@density,@max_mz)
+      
+      @@r_times.each do |k|
+	s_v = @data[k]
+	n_v = @noise[k]
+	if s_v != nil
+	  @spectra[k] = [s_v[0]+n_v[0],s_v[1]+n_v[1]]
+	else
+	  @spectra[k] = [n_v[0],n_v[1]]
+	end
+      end
+      
+      return @noise
+    end
+    
+    def self.r_times
+      @@r_times
+    end
+    
+    attr_reader :data, :max_mz, :spectra, :noise, :features
+    attr_writer :data, :max_mz, :spectra, :noise, :features
+    
+  end
+end
+
+#charge ratio: take both charge states, determine pH effective
+#more small peaks from lesser charge states
+
+#one_d
+#fit to other labs data - different machine

data/lib/ms/sim_trollop.rb

@@ -0,0 +1,68 @@
+require 'ms/curvefit'
+
+module MS
+  class Troll
+    def initialize
+      @opts = Trollop::options do
+        version "mspire-simulator 0.0.1a (c) 2012 Brigham Young University"
+        banner <<-EOS
+        
+        *********************************************************************
+         Description: Simulates ms runs given protein fasta files. Outputs
+         a mzML file.
+         
+         
+        Usage:
+             mspire-simulator [options] <filenames>+
+             
+        where [options] are:
+        EOS
+        opt :digestor, "Digestion Enzyme; one of: \n\t\targ_c,\n \t\tasp_n,
+		asp_n_ambic,
+                chymotrypsin,\n \t\tcnbr,
+                lys_c,\n \t\tlys_c_p,
+                pepsin_a,\n\t\ttryp_cnbr,
+                tryp_chymo,\n \t\ttrypsin_p,
+                v8_de,\n \t\tv8_e,
+                trypsin,\n \t\tv8_e_trypsin,
+                v8_de_trypsin",
+                :default => "trypsin" 
+        opt :sampling_rate, "How many scans per second", :default => 0.5 
+        opt :run_time, "Run time in seconds", :default => 1000.0 
+        opt :noise, "Noise on or off", :default => "true"
+        opt :noise_density, "Determines the density of white noise", :default => 10
+        opt :pH, "The pH that the sample is in - for determining charge", :default => 2.6
+        opt :out_file, "Name of the output file", :default => "test.mzml"
+        opt :contaminants, "Fasta file containing contaminant sequences", :default => "testFiles/contam/hum_keratin.fasta"
+        opt :dropout_percentage, "Defines the percentage of random dropouts in the run. 0.0 <= percentage < 1.0", :default => 0.12
+        opt :shuffle, "Option shuffles the scans to simulate 1d data", :default => "false"
+        opt :one_d, "Turns on one dimension simulation; run_time is automatically set to 300.0", :default => "false"
+        opt :truth, "Determines truth file type; false gives no truth file; one of: xml or csv", :default => "false"
+        opt :front, "Fronting chromatography parameter", :default => 6.65
+        opt :tail, "Tailing chromatography parameter", :default => 0.30
+        opt :mu, "Expected value of the chromatography curve", :default => 25.0
+        opt :wobA, "m/z wobble parameter", :default => 0.001071
+        opt :wobB, "m/z wobble parameter", :default => -0.5430
+        opt :jagA, "intensity variance parameter", :default => 10.34
+        opt :jagC, "intensity variance parameter", :default => 0.00712
+        opt :jagB, "intensity variance parameter", :default => 0.12
+        opt :overlapRange, "range in which to determine overlapping peaks", :default => 1.0724699230489427
+        opt :email, "Email address to send completion messages to", :default => "nil"
+        opt :mzml, "Mzml file to extract simulation parameters from", :default => "nil"
+        opt :generations, "If an mzml file is provided this specifies the number of generations for the curve fitting algorithm", :default => 30000
+        
+      end
+    
+      if @opts[:mzml] != "nil"
+        @opts = CurveFit.get_parameters(@opts)
+      end
+      Trollop::die :sampling_rate, "must be greater than 0" if @opts[:sampling_rate] <= 0
+      Trollop::die :run_time, "must be non-negative" if @opts[:run_time] < 0
+      Trollop::die "must supply a .fasta protien sequence file" if ARGV.empty?
+      Trollop::die :dropout_percentage, "must be between greater than or equal to 0.0 or less than 1.0" if @opts[:dropout_percentage] < 0.0 or @opts[:dropout_percentage] >= 1.0
+      @opts[:overlapRange] = (@opts[:overlapRange]*10.0**-6)/2.0
+    end
+    
+    def get; @opts; end
+  end
+end

data/lib/ms/tr_file_writer.rb

@@ -0,0 +1,175 @@
+require 'progress'
+
+#if m/z value is in "[m/z, percentage contributed to peak]" it's a
+#merged peak. 
+module MS
+  class Txml_file_writer
+    def self.write(features,spectra,file_name)
+      @spectra = spectra
+      @start = Time.now
+      file = File.open("#{file_name}_truth.xml","w")
+      
+      r_times = spectra.keys.sort
+      
+      file.puts "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+      file.puts "<simulated_peptides>"
+	total = features.size.to_f
+	features.each_with_index do |fe,k|
+	  sequence = fe.sequence
+	  charge = fe.charge
+	  mzs = fe.mzs
+	  ints = fe.ints
+	  rts = fe.rts
+	  Progress.progress("Writing xml:",(((k/total)*100).to_i))
+	  file.puts "\t<simulated_peptide sequence=\"#{sequence}\" charge=\"#{charge.round}\">"
+	    mzs.each_with_index do |mzs,i|
+	      tags = ""
+	      centroids = ""
+	      tags<<"\t\t<lc_centroids isotopic_index=\"#{i}\">"
+		mzs.each_with_index do |mz,ind|
+		  if ints[i][ind] > 0.9
+		    index = get_ind(mz,rts[ind])
+		    centroids<<"#{r_times.index(rts[ind])},#{index.inspect};"
+		  end
+		end
+	      if centroids != ""
+		tags<<centroids
+		tags<<"</lc_centroids>\n"
+		file<<tags
+	      end
+	    end
+	  file.puts "\t</simulated_peptide>"
+	end
+      file.puts "</simulated_peptides>"
+      file.close
+      
+      Progress.progress("Writing xml:",100,Time.now-@start)
+      puts ''
+    end
+    
+    def self.get_ind(mz,rt)
+      index = nil
+      if @spectra[rt] != nil
+        mzs = @spectra[rt][0]
+        ints = @spectra[rt][1]
+        mzs.each_with_index do |m, i|
+          if m == mz
+            index = i
+          elsif m.class == Hash
+            if ind = m.values[0].index(mz)
+              index = [i,m.keys[0][ind+1]]
+            end
+          end
+        end
+      end
+      return index
+    end
+  end
+  
+  class Tcsv_file_writer
+    def self.write(full_spectra,spectra,noise,features,file_name)
+      @start = Time.now
+      @spectra = full_spectra
+    
+      #create indices for real peaks
+      ind_hash = create_indicies(features)
+    
+      #create data structure with indices
+      data = data_with_indicies(full_spectra,spectra,noise,ind_hash)
+      
+      #group by retention time
+      data = data.group_by{|d| d[0]}
+      
+      #write
+      file = File.open("#{file_name}_truth.csv","w")
+      file.puts "rt,mz,int,index"
+      total = data.size.to_f
+      count = 0
+      data.each_value do |val|
+	Progress.progress("Writing csv(process 2 of 2):",(((count/total)*100).to_i))
+	val.each do |a|
+	  if a[3] >= 1
+	    file.puts "#{a[0]},#{a[1]},#{a[2]},#{a[3]}"
+	  else
+	    file.puts "#{a[0]},#{a[1]},#{a[2]},#{0}"
+	  end
+	end
+	count += 1
+      end
+      file.close
+      
+      Progress.progress("Writing csv:",100,Time.now-@start)
+      puts ''
+    end
+    
+    def self.get_merged_mz(mz,rt)
+      m_mz = nil
+      int = nil
+      mzs = @spectra[rt][0]
+      ints = @spectra[rt][1]
+      mzs.each_with_index do |m, i|
+	if m == mz
+	  m_mz = mz
+	  int = ints[i]
+	elsif m.class == Hash
+	  if ind = m.values[0].index(mz)
+	    m_mz = [m.keys[0][0],m.keys[0][ind+1]]
+	    int = ints[i].flatten.inject(:+)
+	  end
+	end
+      end
+      return m_mz,int
+    end
+    
+    def self.create_indicies(features)
+      ind_hash = {}
+      features.each_with_index do |pep,i|
+	pep.mzs.each_with_index do |m_ar,j|
+	  m_ar.each do |mz|
+	    ind_hash[mz] = "#{i + 1}.#{j + 1}".to_f
+	  end
+	end
+      end
+      return ind_hash
+    end
+    
+    def self.data_with_indicies(full_spectra,spectra,noise,ind_hash)
+      count = 1
+      time_i = 0.0
+      data = []
+      total = spectra.length
+      spectra.each do |k,v|
+	Progress.progress("Writing csv(process 1 of 2):",(((time_i/total)*100).to_i))
+	
+	merged_d = full_spectra[k]
+	merged_mzs = merged_d[0]
+	merged_ints = merged_d[1]
+	
+	if noise != "false"
+	  n_data = noise[k]
+	end
+	
+	if v != nil
+	  v.each_slice(2) do |m,i|
+	    m.each_with_index do |mz,index|
+	      peak_index = ind_hash[mz]
+	      mz,int = get_merged_mz(mz,k)
+	      data<<[k,mz.inspect,int,peak_index]
+	    end
+	  end
+	end
+	
+	if noise != "false"
+	  n_data.each_slice(2) do |m,i|
+	    m.each_with_index do |mz,index|
+	      mz,int = get_merged_mz(mz,k)
+	      data<<[k,mz.inspect,int,0]
+	    end
+	  end
+	end
+	time_i += 1
+      end
+      return data
+    end
+  end
+end

data/lib/progress.rb

@@ -0,0 +1,24 @@
+
+module Progress
+  module_function
+  def progress(message, num, time = '')
+    # move cursor to beginning of line
+    cr = "\r"           
+
+    # ANSI escape code to clear line from cursor to end of line
+    # "\e" is an alternative to "\033"
+    # cf. http://en.wikipedia.org/wiki/ANSI_escape_code
+    clear = "\e[0K"     
+
+    # reset lines
+    reset = cr + clear
+    if time == ''
+      print "#{reset} #{message}" + "#{num}%".rjust(60-message.length)
+      $stdout.flush
+    else
+      str = "#{reset} #{message}" + "#{num}%".rjust(60-message.length)
+      print  str + "Took: #{"%.2f" % time} sec.".rjust(100-str.length)
+      $stdout.flush
+    end
+  end
+end