mspire-simulator 0.1.2 → 0.2.0

data/lib/ms/sim_digester.rb

@@ -1,10 +1,15 @@
+class String
+  abu = 0
+  attr_reader :abu
+  attr_writer :abu
+end
 
 module MS
   class Sim_Digester
-  
+
     attr_reader :digested_file
     attr_writer :digested_file
-    
+
     def initialize(digestor,pH)
       @digestor = digestor
       @pH = pH
@@ -13,38 +18,47 @@ module MS
       system("mkdir .m/A .m/R .m/N .m/D .m/C .m/E .m/Q .m/G .m/H .m/I .m/L .m/K .m/M .m/F .m/P .m/S .m/T .m/W .m/Y .m/V .m/U .m/O")
       system("mkdir .i/A .i/R .i/N .i/D .i/C .i/E .i/Q .i/G .i/H .i/I .i/L .i/K .i/M .i/F .i/P .i/S .i/T .i/W .i/Y .i/V .i/U .i/O")
     end
-    
+
     def clean
       system("rm -r -f .m .i")
     end
-    
+
     def create_digested_file(file)
+      abundances = []
       inFile = File.open(file,"r")
       seq = ""
       inFile.each_line do |sequence| 
-        if sequence =~ />/ or sequence == "\n"
-          seq = seq<<";"
-        else
+        if sequence =~ />/
+          num = sequence.match(/\#.+/).to_s.chomp.gsub('#','')
+          if num != ""
+            abundances<<(num.to_f)*10.0**-2
+          else
+            abundances<<1.0
+          end
+        sequence
+        seq = seq<<";"
+        elsif sequence == "/n"; else
           seq = seq<<sequence.chomp
         end
       end
       inFile.close
-      
+
       proteins = seq.split(/;/).delete_if{|str| str == ""}
 
       trypsin = Mspire::Digester[@digestor]
-      
+
       digested = []
       d_file = File.open(@digested_file, "w")
-      proteins.each do |prot|
+      proteins.each_with_index do |prot,index|
         dig = trypsin.digest(prot)
         dig.each do |d|
+          d.abu = abundances[index]
           digested<<d
         end
       end
       proteins.clear
       digested.uniq!
-      
+
       trun_digested = []
       if digested.length > 50000
         50000.times do 
@@ -53,9 +67,9 @@ module MS
         digested.clear
         digested = trun_digested
       end
-      
+
       digested.each do |dig|
-        d_file.puts(dig)
+        d_file.puts(dig<<"#"<<dig.abu.to_s)
       end
       d_file.close
       num_digested = digested.size
@@ -63,36 +77,41 @@ module MS
       puts "Number of peptides: #{num_digested}"
       return num_digested
     end
-    
+
     def digest(file)
-      start = Time.now
-      
       num_digested = create_digested_file(file)
-      
+
       d_file = File.open(@digested_file, "r")
       i = 0
-      
+
       peptides = []
 
+      prog = Progress.new("Creating peptides '#{file}':")
+      num = 0
+      total = num_digested
+      step = total/100.0
       d_file.each_line do |peptide_seq|
         peptide_seq.chomp!
-        Progress.progress("Creating peptides '#{file}':",((i/num_digested.to_f)*100.0).to_i)
-        
+        peptide_seq.abu = peptide_seq.match(/#.+/).to_s.chomp.gsub('#','').to_f
+          peptide_seq.gsub!(/#.+/,'')
+          if i > step * (num + 1)
+            num = ((i/total.to_f)*100.0).to_i
+            prog.update(num)
+          end
+
         charge_ratio = charge_at_pH(identify_potential_charges(peptide_seq), @pH)
         charge_f = charge_ratio.floor
         charge_c = charge_ratio.ceil
-        
-        peptide_f = MS::Peptide.new(peptide_seq, charge_f) if charge_f != 0
-        peptide_c = MS::Peptide.new(peptide_seq, charge_c) if charge_c != 0
-      
+        peptide_f = MS::Peptide.new(peptide_seq, charge_f, peptide_seq.abu) if charge_f != 0
+        peptide_c = MS::Peptide.new(peptide_seq, charge_c, peptide_seq.abu) if charge_c != 0
+
         peptides<<peptide_f if charge_f != 0
         peptides<<peptide_c if charge_c != 0
         i += 1
       end
+      prog.finish!
       d_file.close
       File.delete(@digested_file)
-      Progress.progress("Creating peptides '#{file}':",100,Time.now-start)
-      puts ''
       return peptides
     end
   end

data/lib/ms/sim_feature.rb

@@ -1,173 +1,231 @@
-
 require 'time'
 require 'distribution'
+require 'fragmenter'
 require 'ms/sim_peptide'
 require 'ms/rt/rt_helper'
 require 'ms/tr_file_writer'
 
+class Array
+  attr_reader :ms2, :ms_level, :pre_mz, :pre_int, :pre_charge
+  attr_writer :ms2, :ms_level, :pre_mz, :pre_int, :pre_charge
+end
+
 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
-      
-      
+      @max_mz = -1
+
+
       #------------------Each_Peptide_=>_Feature----------------------
+      prog = Progress.new("Generating features:")
+      num = 0
+      total = peptides.size
+      step = total/100.0
       peptides.each_with_index do |pep,ind|
-	Progress.progress("Generating features:",(((ind+1)/peptides.size.to_f)*100).to_i)	
-	
-	feature = getInts(pep)
+        if ind > step * (num + 1)
+          num = (((ind+1)/total.to_f)*100).to_i
+          prog.update(num)
+        end
+
+        feature = getInts(pep)
 
-	@features<<feature
+        @features<<feature
       end
-      Progress.progress("Generating features:",100,Time.now-@start)
-      puts ""
-      @start = Time.now
+      prog.finish!
       #---------------------------------------------------------------
-      
-      
-      
+
+
+
       #-----------------Transform_to_spectra_data_for_mzml------------
       # rt => [[mzs],[ints]]
+      prog = Progress.new("Generating MS2 & Populating structure for mzml:")
+      num = 0
+      total = @features.size
+      step = total/100.0
+      ms2_count = 0
+      seq = nil
+      
       @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
+        if k > step * (num + 1)
+          num = ((k/total.to_f)*100).to_i
+          prog.update(num)
+        end
+
+        fe_ints = fe.ints 
+        fe_mzs = fe.mzs
+
+        ms2_int = fe.ints.flatten.max
+        ms2 = false
+        pre_mz = nil
+        pre_charge = nil
+
+        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 @max_mz < mz
+              @max_mz = mz
+            end
+            if int == nil
+              int = 0.0
+            end
+            if int > 0.9
+              rt_mzs<<mz
+              rt_ints<<int
+              if int == ms2_int and fe.sequence.size > 1
+                ms2 = true
+                pre_mz = mz
+                pre_charge = fe.charge
+              end
+            end
+          end
+
+          spec = nil
+          if rt_mzs.include?(nil) or rt_mzs.empty?; else
+            if @data.key?(rt)
+              ms1 = @data[rt]
+              spec = [ms1[0] + rt_mzs, ms1[1] + rt_ints]
+              spec.ms_level = ms1.ms_level
+              spec.ms2 = ms1.ms2
+            else
+              spec = [rt_mzs, rt_ints]
+            end
+            if false#ms2 and fe.sequence != seq
+              #add ms2 spec
+	      seq = fe.sequence
+              spec.ms_level = 2
+              ms2_mzs = MS::Fragmenter.new.fragment(seq)
+              ms2_ints = Array.new(ms2_mzs.size,500.to_f)
+              spec2 = [(rt + RThelper.RandomFloat(0.01,@opts[:sampling_rate] - 0.1)), ms2_mzs, ms2_ints]
+              spec2.ms_level = 2
+              spec2.pre_mz = pre_mz
+              spec2.pre_int = ms2_int
+              spec2.pre_charge = pre_charge
+              if spec.ms2 != nil
+                ms2_arr = spec.ms2
+                ms2_arr<<spec2
+                spec.ms2 = ms2_arr
+              else
+                spec.ms2 = [spec2]
+              end
+              ms2_count += 1
+            end
+            @data[rt] = spec
+          end
+          ms2 = false
+        end
       end
-      Progress.progress("Populating structure for mzml:",100,Time.now-@start)
-      puts ""
-      
+      prog.finish!
+      puts "MS2s = #{ms2_count}"
+
       #---------------------------------------------------------------
-      
+
     end
-    
-    attr_reader :data, :features
-    attr_writer :data, :features
-    
+
+    attr_reader :data, :features, :max_mz
+    attr_writer :data, :features, :max_mz
+
     # 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
+        p_int -= 10
       end
-      predicted_int = (p_int * 10**-1) * 14183000.0
+      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
-      
+      sx = pep.sx
+      sy = (sx**-1) * Math.sqrt(pep.abu)
+
       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
+        fin_mzs = []
+        fin_ints = []
+
+        relative_abundances_int = relative_ints[index]
+
+        t_index = 1
+
+        pep.rts.each_with_index do |rt,i| 
+
+          if !@one_d
+            #-------------Tailing-------------------------
+            shape = (tail * (t_index / sx)) + front
+            fin_ints << (RThelper.gaussian((t_index / sx) ,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
+    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
+
+if fin_ints[i] > 0.4
+  #-------------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
+  #---------------------------------------------
+end
+
+#-------------mz wobble-----------------------
+y = fin_ints[i]
+wobble_mz = nil
+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)) * sy
+        end
+
+        pep.insert_ints(fin_ints)
+        pep.insert_mzs(fin_mzs)
+
+        index += 1
       end
       return pep
     end