mspire 0.6.7 → 0.6.9

data/lib/ms/mzml/precursor.rb

@@ -0,0 +1,42 @@
+require 'ms/mzml/list'
+
+module MS
+  class Mzml
+    # The method of precursor ion selection and activation
+    class Precursor
+      # (optional) the MS::Mzml::Spectrum object from which the precursor is
+      # derived
+      attr_accessor :spectrum
+
+      # (optional)
+      attr_accessor :isolation_window 
+
+      # (optional) An array of ions that were selected.
+      attr_accessor :selected_ions
+
+      # (required) The type and energy level used for activation.
+      attr_accessor :activation
+
+      # a boolean indicating the spectrum is from an external source file
+      attr_accessor :from_external_source_file
+
+      def to_xml(builder)
+        atts = {}
+        if @from_external_source_file
+          atts[:sourceFileRef] = @spectrum.source_file.id
+          atts[:externalSpectrumRef] = @spectrum.id
+        else
+          atts[:spectrumRef] = @spectrum.id if @spectrum
+        end
+        builder.precursor(atts) do |prec_n|
+          @isolation_window.to_xml(prec_n) if @isolation_window
+          MS::Mzml::SelectedIonList.list_xml(@selected_ions, prec_n) if @selected_ions
+          @activation.to_xml(prec_n)
+        end
+      end
+
+      extend(MS::Mzml::List)
+
+    end
+  end
+end

data/lib/ms/mzml/processing_method.rb

@@ -0,0 +1,24 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    class ProcessingMethod
+      include MS::CV::Paramable
+
+      attr_accessor :order, :software
+
+      def initialize(order, software, opts={params: []}, &block)
+        @order, @software = order, software
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.processingMethod(order: @order, softwareRef: software.id) do |pm_n|
+          super(pm_n) # params
+        end
+        builder
+      end
+    end
+  end
+end

data/lib/ms/mzml/product.rb

@@ -0,0 +1,22 @@
+require 'ms/mzml/list'
+
+module MS
+  class Mzml
+    class Product
+      attr_accessor :isolation_window
+
+      def initialize(isolation_window=nil)
+        @isolation_window = isolation_window
+      end
+
+      def to_xml(builder)
+        builder.product do |p_n|
+          @isolation_window.to_xml(p_n) if @isolation_window
+        end
+      end
+
+      extend(MS::Mzml::List)
+    end
+  end
+end
+

data/lib/ms/mzml/referenceable_param_group.rb

@@ -0,0 +1,40 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+
+    # need to call to_xml_definition (or use
+    # MS::Mzml::ReferenceableParamGroupList.list_xml) to get the xml for the
+    # object itself (and not a reference).  Merely callying #to_xml will
+    # result in a referenceableParamGroupRef being created.
+    class ReferenceableParamGroup
+      include MS::CV::Paramable
+
+      attr_accessor :id
+
+      def initialize(id, opts={params: []} )
+        @id = id
+        describe!(*opts[:params])
+      end
+
+      def to_xml(builder)
+        builder.referenceableParamGroupRef(ref: @id)
+        builder
+      end
+
+      def to_xml_definition(builder)
+        builder.referenceableParamGroup(id: @id) do |fc_n|
+          @params.each {|obj| obj.to_xml(fc_n) }
+        end
+        builder
+      end
+
+      def self.list_xml(objs, builder)
+        builder.referenceableParamGroupList(count: objs.size) do |rpgl_n|
+          objs.each {|obj| obj.to_xml_definition(rpgl_n) }
+        end
+        builder
+      end
+    end
+  end
+end

data/lib/ms/mzml/run.rb

@@ -0,0 +1,54 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    class Run
+      include MS::CV::Paramable
+
+      # required
+      attr_accessor :default_instrument_configuration
+
+      # optional
+      attr_accessor :default_source_file
+
+      # required
+      attr_accessor :id
+
+      # optional
+      attr_accessor :sample
+
+      # optional
+      attr_accessor :start_time_stamp
+
+      # a SpectrumList object (a special array of spectra)
+      attr_accessor :spectrum_list
+
+      # takes a ChromatogramList object (a special array of chromatograms)
+      attr_accessor :chromatogram_list
+
+      # yields self if given a block
+      def initialize(id, default_instrument_configuration, opts={params: []}, &block)
+        @id = id
+        @default_instrument_configuration = default_instrument_configuration
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        atts = { id: @id,
+          defaultInstrumentConfigurationRef: @default_instrument_configuration.id
+        }
+        atts[:defaultSourceFileRef] = @default_source_file.id if @default_source_file
+        atts[:sampleRef] = @sample.id if @sample
+        atts[:startTimeStamp] = @start_time_stamp if @start_time_stamp
+        
+        builder.run(atts) do |run_n|
+          super(run_n)
+          spectrum_list.to_xml(run_n) if spectrum_list
+          chromatogram_list.to_xml(run_n) if chromatogram_list
+        end
+        builder
+      end
+    end
+  end
+end

data/lib/ms/mzml/sample.rb

@@ -0,0 +1,27 @@
+require 'ms/cv/paramable'
+require 'ms/mzml/list'
+
+module MS
+  class Mzml
+    class Sample
+      include MS::CV::Paramable
+
+      attr_accessor :id, :name
+
+      def initialize(id, name, opts={params: []}, &block)
+        @id, @name = id, name
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.sample( id: @id, name: @name ) do |sample_n|
+          super(sample_n)
+        end
+        builder
+      end
+
+      extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/scan.rb

@@ -0,0 +1,44 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    class Scan
+      include MS::CV::Paramable
+
+      # (optional) the MS::Mzml::Spectrum object from which the precursor is
+      # derived.  (the sourceFileRef is derived from this spectrum object if
+      # from_external_source_file == true)
+      attr_accessor :spectrum
+
+      # a boolean indicating the spectrum is from an external source file
+      attr_accessor :from_external_source_file
+
+      # an InstrumentConfiguration object
+      attr_accessor :instrument_configuration
+
+      # ScanWindow objects
+      attr_accessor :scan_windows
+
+      def initialize(opts={params: []}, &block)
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        atts = {}
+        if @from_external_source_file
+          atts[:sourceFileRef] = @spectrum.source_file.id
+          atts[:externalSpectrumRef] = @spectrum.id
+        else
+          atts[:spectrumRef] = @spectrum.id if @spectrum
+        end
+        atts[:instrumentConfigurationRef] = @instrument_configuration.id if @instrument_configuration
+        builder.scan(atts) do |prec_n|
+          super(prec_n) # description
+          ScanWindow.list_xml(@scan_windows, prec_n) if @scan_windows
+        end
+      end
+
+    end
+  end
+end

data/lib/ms/mzml/scan_list.rb

@@ -0,0 +1,33 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+
+    # MUST supply a *child* term of MS:1000570 (spectra combination) only once
+    #
+    #     e.g.: MS:1000571 (sum of spectra)
+    #     e.g.: MS:1000573 (median of spectra)
+    #     e.g.: MS:1000575 (mean of spectra)
+    #     e.g.: MS:1000795 (no combination)
+    class ScanList < Array
+      include MS::CV::Paramable
+
+      def initialize(opts={params: []}, &block)
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.scanList(count: self.size) do |sl_n|
+          @description.to_xml(sl_n) if @description
+          self.each do |scan|
+            scan.to_xml(sl_n)
+          end
+        end
+        builder
+      end
+
+      alias_method :list_xml, :to_xml
+    end
+  end
+end

data/lib/ms/mzml/scan_settings.rb

@@ -0,0 +1,28 @@
+require 'ms/mzml/list'
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    class ScanSettings
+      include MS::CV::Paramable
+
+      attr_accessor :id
+
+      def initialize(id, opts={params: []}, &block)
+        @id = id
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.scanSettings( id: @id ) do |ss_n|
+          super(ss_n)
+        end
+        builder
+      end
+
+      extend(MS::Mzml::List)
+
+    end
+  end
+end

data/lib/ms/mzml/selected_ion.rb

@@ -0,0 +1,18 @@
+require 'ms/mzml/list'
+require 'ms/cv/paramable'
+
+
+module MS
+  class Mzml
+    # MUST supply a *child* term of MS:1000455 (ion selection attribute) one or more times
+    #
+    #     e.g.: MS:1000041 (charge state)
+    #     e.g.: MS:1000042 (intensity)
+    #     e.g.: MS:1000633 (possible charge state)
+    #     e.g.: MS:1000744 (selected ion m/z)
+    class SelectedIon
+      include MS::CV::Paramable
+      extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/software.rb

@@ -0,0 +1,28 @@
+require 'mspire'
+require 'ms/mzml/list'
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    class Software
+      include MS::CV::Paramable
+
+      attr_accessor :id, :version
+
+      def initialize(id='mspire', version=Mspire::VERSION, opts={params: []}, &block)
+        @id, @version = id, version
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.software( id: @id, version: @version) do |sf_n|
+          super(sf_n)
+        end
+        builder
+      end
+
+      extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/source_file.rb

@@ -0,0 +1,48 @@
+require 'ms/cv/paramable'
+require 'ms/mzml/list'
+require 'pathname'
+
+module MS
+  class Mzml
+    class SourceFile
+      include MS::CV::Paramable
+
+      DEFAULT_SOURCEFILE_ID = 'sourcefile1'
+
+      # (required) An identifier for this file.
+      attr_accessor :id
+      # (required) Name of the source file, without reference to location
+      # (either URI or local path).
+      attr_accessor :name
+      # (required) URI-formatted location where the file was retrieved.
+      attr_accessor :location
+
+      # expands the path and sets the name and location
+      def self.[](path, opts={})
+        self.new DEFAULT_SOURCEFILE_ID, *uri_basename_and_path(path)
+      end
+
+      def self.uri_basename_and_path(file)
+        pathname = Pathname.new(path)
+        dir = pathname.expand_path.dirname
+        dir = '/'+dir unless (dir[0] == '/')
+        [pathname.basename, 'file://'+ dir]
+      end
+
+      def initialize(id="sourcefile1", name="mspire-simulated", location='file://', opts={params: []}, &block)
+        @id, @name, @location = id, name, location
+        describe!(*opts[:params])
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.sourceFile( id: @id, name: @name, location: @location ) do |sf_n|
+          super(sf_n)
+        end
+        builder
+      end
+
+      extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/spectrum.rb

@@ -0,0 +1,91 @@
+require 'ms/mzml/data_array_container_like'
+require 'ms/spectrum_like'
+require 'ms/mzml/data_array'
+require 'ms/mzml/scan_list'
+require 'ms/mzml/precursor'
+require 'ms/mzml/product'
+
+module MS
+  class Mzml
+
+    #     MAY supply a *child* term of MS:1000465 (scan polarity) only once
+    #       e.g.: MS:1000129 (negative scan)
+    #       e.g.: MS:1000130 (positive scan)
+    #     MUST supply a *child* term of MS:1000559 (spectrum type) only once
+    #       e.g.: MS:1000322 (charge inversion mass spectrum)
+    #       e.g.: MS:1000325 (constant neutral gain spectrum)
+    #       e.g.: MS:1000326 (constant neutral loss spectrum)
+    #       e.g.: MS:1000328 (e/2 mass spectrum)
+    #       e.g.: MS:1000341 (precursor ion spectrum)
+    #       e.g.: MS:1000581 (CRM spectrum)
+    #       e.g.: MS:1000582 (SIM spectrum)
+    #       e.g.: MS:1000583 (SRM spectrum)
+    #       e.g.: MS:1000789 (enhanced multiply charged spectrum)
+    #       e.g.: MS:1000790 (time-delayed fragmentation spectrum)
+    #       et al.
+    #     MUST supply term MS:1000525 (spectrum representation) or any of its children only once
+    #       e.g.: MS:1000127 (centroid spectrum)
+    #       e.g.: MS:1000128 (profile spectrum)
+    #     MAY supply a *child* term of MS:1000499 (spectrum attribute) one or more times
+    #       e.g.: MS:1000285 (total ion current)
+    #       e.g.: MS:1000497 (zoom scan)
+    #       e.g.: MS:1000504 (base peak m/z)
+    #       e.g.: MS:1000505 (base peak intensity)
+    #       e.g.: MS:1000511 (ms level)
+    #       e.g.: MS:1000527 (highest observed m/z)
+    #       e.g.: MS:1000528 (lowest observed m/z)
+    #       e.g.: MS:1000618 (highest observed wavelength)
+    #       e.g.: MS:1000619 (lowest observed wavelength)
+    #       e.g.: MS:1000796 (spectrum title)
+    #       et al.
+    class Spectrum
+      include MS::SpectrumLike
+      include MS::Mzml::DataArrayContainerLike
+
+      # (optional) an MS::Mzml::SourceFile object
+      attr_accessor :source_file
+
+      # (optional) The identifier for the spot from which this spectrum was derived, if a
+      # MALDI or similar run.
+      attr_accessor :spot_id
+
+      ###########################################
+      # SUBELEMENTS
+      ###########################################
+
+      # (optional) a ScanList object
+      attr_accessor :scan_list
+
+      # (optional) List and descriptions of precursor isolations to the spectrum
+      # currently being described, ordered.
+      attr_accessor :precursors
+
+      # (optional) List and descriptions of product isolations to the spectrum
+      # currently being described, ordered.
+      attr_accessor :products
+
+      # the most common param to pass in would be ms level: 'MS:1000511'
+      #
+      # This would generate a spectrum of ms_level=2 :
+      #
+      #     MS::Mzml::Spectrum.new(0, "scan=1", 'MS:1000511')
+      def initialize(*args, &block)
+        super(*args)
+        block.call(self) if block
+      end
+
+      # see SpectrumList for generating the entire list
+      def to_xml(builder)
+        atts = {}
+        atts[:sourceFile] = @source_file.id if @source_file
+        atts[:spotID] = @spot_id if @spot_id
+        super(builder, atts) do |node|
+          @scan_list.list_xml( node ) if @scan_list
+          MS::Mzml::Precursor.list_xml(@precursors, node) if @precursors
+          MS::Mzml::Product.list_xml(@products, node) if @products
+        end
+      end
+
+    end
+  end
+end

data/lib/ms/mzml/spectrum_list.rb

@@ -0,0 +1,42 @@
+require 'ms/mzml/spectrum'
+
+module MS
+  class Mzml
+    class SpectrumList < Array
+
+      # a DataProcessing object
+      attr_reader :default_data_processing
+
+      def initialize(default_data_processing, spectra=[])
+        @default_data_processing = default_data_processing
+        super(spectra)
+      end
+
+      # This method takes an MS::Spectrum object and transforms it into an
+      # MS::Mzml::Spectrum object and puts it in the internal list
+      def add_ms_spectrum(spectrum, id)
+        mzml_spec = MS::Mzml::Spectrum.new(id)
+        mzml_spec.data = spectrum.data
+        self << mzml_spec
+      end
+
+      # takes an array of spectra and performs add_spectrum on each
+      # returns self
+      def add_spectra(spectra, ids=[])
+        spectra.zip(ids).each_with_index {|(spec,id),i| add_spectrum(spec, "spectrum=#{i+1}") }
+        self
+      end
+
+      def to_xml(builder)
+        builder.spectrumList(count: self.size, defaultDataProcessingRef: @default_data_processing.id) do |spl_n|
+          self.each_with_index do |spectrum,i|
+            spectrum.index = i unless spectrum.index
+            spectrum.to_xml(spl_n)
+          end
+        end
+        builder
+      end
+
+    end
+  end
+end