Main module for msJ.jl– A Julia package to load and process mass spectrometry data.

abstract type MScontainer  end

Abstract type containing any imported data belongs to the MScontainer type.

struct MSscan <: MScontainer

Data structure used to store individual mass spectrometry scans organized following the structure of mzXML files.

struct MSscan <: MScontainer num::Int # num rt::Float64 # retentionTime tic::Float64 # totIonCurrent mz::Vector{Float64} # m/z int::Vector{Float64} # intensity level::Int # msLevel basePeakMz::Float64 # basePeakMz basePeakIntensity::Float64 # basePeakIntensity precursor::Float64 # precursorMz polarity::String # polarity activationMethod::String # activationMethod collisionEnergy::Float64 # collisionEnergy end

struct MSscans  <: MScontainer

Data structure designed to store mass spectra obtained after filtering operation along with the history of these operation.

struct MSscans <: MScontainer num::Vector{Int} # num rt::Vector{Float64} # retentionTime tic::Float64 # totIonCurrent mz::Vector{Float64} # m/z int::Vector{Float64} # intensity level::Vector{Int} # msLevel basePeakMz::Float64 # basePeakMz basePeakIntensity::Float64 # basePeakIntensity precursor::Vector{Float64} # precursorMz polarity::Vector{String} # polarity activationMethod::Vector{String} # activationMethod collisionEnergy::Vector{Float64} # collisionEnergy s::Vector{Float64} # variance end

struct Chromatogram  <: MScontainer

Data structure used to retrieve chromatography data.

struct Chromatogram <: MScontainer rt::Vector{Float64} ic::Vector{Float64} maxic::Float64 end

abstract type MethodType  end

Type containing all the methods used for filtering the data.

struct BasePeak <: MethodType

Structure for multiple dispatching to retrieve base peak chromatogram.

struct TIC <: MethodType

Dispatching to retrieve total ion current chromatogram.

struct ∆MZ{argT <: Union{Real, AbstractVector{<:Real} }} <: MethodType

Structure for multiple dispatching to retrieve extracted ion current chromatogram around an m/z ± ∆mz value given by arg = [mz, ∆mz]

struct MZ{argT <: Union{Real, AbstractVector{<:Real} }} <: MethodType

Structure for multiple dispatching to retrieve extracted ion current chromatogram around for m/z in the range arg = [mz1, mz2].

struct SG{argT <: Int} <: MethodType   #Savinsky & Golay filtering

Structure for multiple dispatching to Savinsky & Golay filtering, providing the order, window size and derivative to be performed. Defaults values are provided in functions calls.

struct TBPD{argT1 <: Symbol, argT2 <: Real}  <: MethodType

Structure for multiple dispatching to Template Base Peak Detection centroiding, providing the shape of the template function, the resolution and threshold. Defaults values are provided in functions calls.

struct SNRA{argT1 <: Real, argT2 <: Int}  <: MethodType

Structure for multiple dispatching to Signal to Noise Ratio Analysis centroiding, providing the threshold value and the size of the region. Defaults values are provided in functions calls.

TopHat{argT <: Int} <: MethodType

Structure for multiple dispatching to TopHat baseline correction. Region is used specify the dimention over which this operation performed

LOESS{argT <: Int} <: MethodType

Structure for multiple dispatching to LOcally Weighted Error Sum of Squares regression (LOESS) baseline correction.

struct IPSA{argT1 <: Int, argT2 <: Real} <: MethodType

Structure for multiple dispatching to iterative polynomial smoothing algorithm (IPSA) baseline correction.

abstract type FilterType end

This type contains the structures for filtering the data.

RT{argT <: Union{Real, AbstractVector{<:Real},  AbstractVector{<:AbstractVector{<:Real}} }}

This type contains the structures for filtering the data.

struct IC{argT <: Union{Real, AbstractVector{<:Real} }} <: FilterType

Used for multiple dispatching to Template Base Peak Detection centroiding, providing the shape of the template function, the resolution and threshold. Defaults values are provided in functions calls.

struct Level{argT <: Union{Int, AbstractVector{<:Int} }} <: FilterType

Used to dispatch filters to MS level.

 Scan{argT <: Union{Int, AbstractVector{<:Int} }} <: FilterType

Dispatch filter to scan num.

struct Polarity{argT <: Union{String, AbstractVector{<:String} }} <: FilterType

Dispatch filter to polarity.

struct Activation_Method{argT <: Union{String, AbstractVector{<:String} }} <: FilterType

Dispatch filter to activation methods

struct Activation_Energy{argT <: Union{Real, AbstractVector{<:Real} }} <: FilterType

Dispatch filter to activation energies.

struct Precursor{argT <: Union{Real, AbstractVector{<:Real} }} <: FilterType

Dispatch filter to precursor.

info(filename::String, verbose::Bool = false)

The function looks into an file and returns in an Array{String} containing the number of scans and the different scans described by their MS level, polarity and eventually the precursor m/z followed by the activation method and collision energy. Each entry is unique, which gives a summary of the input file. With verbose = true, the functions also returns the parentFile, msManufacturer, msModel, msIonisation, msMassAnalyzer, msDetector, software and dataProcessing if existing.

Example

julia> info("test1.mzXML")
4-element Array{String,1}:
 "51 scans"               
 "MS1+"                   
 "MS2+ 1255.5  CID(CE=18)"
 "MS3+ 902.33  PQD(CE=35)"
julia> MSj.info("test1.mzXML", verbose = true)
12-element Array{String,1}:
 "parentFile: test1_MSj_1.raw"
 "msManufacturer: Thermo Finnigan"
 "msModel: LTQ XL"      
 "msIonisation: ESI"
 "msMassAnalyzer: ITMS"
 "msDetector: unknown"
 "software: Xcalibur, 2.6.0 SP3"
 "dataProcessing: conversion, ReAdW 4.3.1(build Sep  9 2009 12:30:29)"
 "51 scans"
 "MS1+"
 "MS2+ 1255.5  CID(CE=18)"
 "MS3+ 902.33  PQD(CE=35)"

function load(filename::String)

Checks the file extension and calls the right function to load the mass spectra if it exists. Returns an array of MSj.MSscan where the individual mass spectra are stored.

Examples

julia> scans = load("test.mzXML")
51-element Array{MSj.MSscan,1}:
 MSj.MSscan(1, 0.1384, 5.08195e6, [140.083, 140.167, 140.25, 140.333, 140.417, 140.5, 140.583, 140.667, 140.75, 140.833  …  1999.25, 1999.33, 1999.42, ....

retention_time(filename::String)

Returns an array composed of the retention times of the individual mass spectra.

Examples

julia> retention_time("test.mzXML")
51-element Array{Float64,1}:
  0.1384
  0.7307
  2.1379
....

chromatogram(filename::String, filters::FilterType...; method::MethodType=TIC())

Returns a structure holding the retention time (rt), the ion current (ic) and the maximum value (maxic) for all the mass spectra within the file. Alternatively, other options may be supplied such as method = MSj.BasePeak, which returns the base peak intensity, method = MSj.∆MZ([500,5]), which returns the ion current for the range mz = 500 ± 5, or method = MSj.MZ([200,1000]) which return the ion current in the range from m/z 200 to m/z 1000. The data may be filtered by ms level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method")...

Examples

julia> rt, ic = chromatogram("test.mzxml")
([0.1384  …  60.4793], [4.74795e6  …  17.4918])
julia> rt, ic = chromatogram("test.mzxml", method = MSj.BasePeak() )
([0.1384  …  60.4793], [102558.0  …  1.23181])
julia> rt, ic = chromatogram("test.mzxml", method = MSj.∆MZ([500,5]) )
([0.1384  …  60.4793], [46036.6  …  14.2529])
julia> rt, ic = chromatogram("test.mzxml", method = MSj.MZ([200,1000]))
([0.1384  …  60.4793], [4.74795e6  …  17.4918])

average(filename::String, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within file. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

info_mzxml(filename::String, info::Vector{String}, verbose::Bool=false)

Returns the information content of an mzXML file into a string. Verbosity is controlled by the verbose Boolean variable set by default to false.

load_mzxml_all(filename::String)

Load an entire an mzxml file, and return the

load_mzxml(filename::String, index::Int

Load from an mzxml file the scan num that match the input index

load_mzxml_spectrum(c::XMLElement)

From an XMLElement, returns the data into an MSscan.

retention_time(msRun::XMLElement)

From an XMLE element returns the retention time.

extracted_chromatogram(filename::String, indices::Vector{Int},method::MethodType)

Returns the extracted chromatogram for input file according to the selected method and for set of scan num as input

composite_spectra(filename::String, indices::Vector{Int}, stats::Bool)

Returns the average MSscans for input filename and according to the input scan num. Calculation of variance is controlled by the stats Boolean variable.

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

chromatogram(scans::Vector{MSscan}, filters::FilterType...; method::MethodType=TIC())

Returns the retention time and the total ion current by default for all the mass spectra within the Array of mass spectrum container MSscan. Alternatively, other options may be supplied such as method = MSj.BasePeak, which returs the base peak intensity, method = MSj.∆MZ([500,5]), which returns the ion current for the range mz = 500 ± 5, or method = MSj.MZ([200,1000]) which return the ion current in the range from m/z 200 to m/z 1000. The data may be filtered by ms level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method")...

Examples

julia> rt, ic = chromatogram("test.mzxml")
([0.1384  …  60.4793], [4.74795e6  …  17.4918])
julia> rt, ic = chromatogram("test.mzxml", method = MSj.BasePeak() )
([0.1384  …  60.4793], [102558.0  …  1.23181])
julia> rt, ic = chromatogram("test.mzxml", method = MSj.∆MZ([500,5]) )
([0.1384  …  60.4793], [46036.6  …  14.2529])
julia> rt, ic = chromatogram("test.mzxml", method = MSj.MZ([200,1000]))
([0.1384  …  60.4793], [4.74795e6  …  17.4918])

retention_time(scans::Vector{MSscan})

Returns an array composed of the retention times of the individual mass spectra.

Examples

julia> retention_time("scans")
51-element Array{Float64,1}:
  0.1384
  0.7307
  2.1379
....

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

average(scans::Vector{MSscan}, arguments::FilterType...; stats::Bool=true)

Returns the average mass spectrum container (MSscans) along with the sample standard deviation of the intensities with stats=true (default) for all the mass spectra within the Array of mass spectrum container MSscan.. The data may be filtered by level, precursor mass, activation methods, etc, using the arguments MSj.Level(N), MSj.Precursor(mz), MSj.Activation_Method("method"), or any combination of these arguments.

Examples

julia> spectrum = average("test.mzxml")
MSj.MSscans([1, 2, 3 ....
julia> spectrum = average("test.mzxml", MSj.Level(1) )
MSj.MSscans([1, 4, 7, 10,
julia> spectrum = average("test.mzxml", MSj.Precursor(1255.5) )
MSj.MSscans([2, 5, 8, 11, ...
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD") )
MSj.MSscans([3, 6, 9, 12, 15,
julia> spectrum = average("test.mzxml", MSj.Activation_Method("PQD"), MSj.Polarity("+"), MSj.RT([10,20]))
MSj.MSscans([9, 12, 15, 18], ...

extracted_chromatogram(scans::Vector{MSscan}, indices::Vector{Int},method::MethodType)

Returns the extracted chromatogram for input Array of MSscan according to the selected method and for set of scan num as input

composite_spectra(scans::Vector{MSscan}, indices::Vector{Int}, stats::Bool)

Returns the average MSscans for input Array of MSscan and according to the input scan num. Calculation of variance is controlled by the stats Boolean variable.

extract(filename::String, arguments::FilterType...)

Search for scans matching the argument MS level and returns an array of matching MSscans otherwise returns an ErrorException: "No matching spectra found."

Examples

julia> sub_set = extract("test.mzxml")
6-element Array{MSj.MSscan,1}:
 MSj.MSscan(1, 0.1384, 5.08195e6, [140.083, 140.167, 140.25, 140.333, 140.417, 140.5, 140.583, 140.667, 140.75, 140.833  …  1999.25, 1999.33, 1999.42, ....
julia> sub_set = extract("test.mzxml", MSj.Level(2) )      # extract MS/MS spectra
MSj.MSscan(2, 0.7307, 9727.2, [345.083, 345.167, 345.25, 345.333, 345.417, 345.5, 345.583, 345.667, 345.75, 345.833  …  1999.25, 1999.33, 1999.42, 1999.5, 1999.58 ....
 MSj.MSscan(5, 4.3442, 12203.5, [345.083, 345.167, 345.25, 345.333, 345.417, 345.5, 345.583, 345.667, 345.75, 345.833  …  1999.25, 1999.33, 1999.42, 1999.5, 1999.58, ....

extract(scans::Vector{MSscan}, arguments::FilterType...)

Search for scans matching the argument MS level and returns an array of matching MSscans otherwise returns an ErrorException: "No matching spectra found."

Examples

julia> scans = load("test.mzxml")                          # load mass spectra
6-element Array{MSj.MSscan,1}:
 MSj.MSscan(1, 0.1384, 5.08195e6, [140.083, 140.167, 140.25, 140.333, 140.417, 140.5, 140.583, 140.667, 140.75, 140.833  …  1999.25, 1999.33, 1999.42, ...
julia> sub_set = extract(scans)                            # extract a sub_set without conditions returns the original data
6-element Array{MSj.MSscan,1}:
 MSj.MSscan(1, 0.1384, 5.08195e6, [140.083, 140.167, 140.25, 140.333, 140.417, 140.5, 140.583, 140.667, 140.75, 140.833  …  1999.25, 1999.33, 1999.42, ....
julia> sub_set = extract(scans, MSj.Level(2) )      # extract MS/MS spectra
MSj.MSscan(2, 0.7307, 9727.2, [345.083, 345.167, 345.25, 345.333, 345.417, 345.5, 345.583, 345.667, 345.75, 345.833  …  1999.25, 1999.33, 1999.42, 1999.5, 1999.58 ....
 MSj.MSscan(5, 4.3442, 12203.5, [345.083, 345.167, 345.25, 345.333, 345.417, 345.5, 345.583, 345.667, 345.75, 345.833  …  1999.25, 1999.33, 1999.42, 1999.5, 1999.58, ....

build_subset(filename::String, indices::Vector{Int})

Returns a Vector of MSscan from the input file according to the scan num (indices).

build_subset(scans::Vector{MSscan}, indices::Vector{Int})

Returns a Vector of MSscan according to the input scan num.

smooth(scan::MScontainer; method::MethodType=SG(5, 9))

Smooth the intensity of the input data and returns a similar structure.

Examples

julia> smoothed_data = MSj.smooth(scans)
MSj.MSscans(1, 0.1384, 5.08195e6, [140.083, 140.167, 140.25, 140.333, 140.417, 140.5, 140.583, 140.667, 140.75, 140.833  …  1999.25, 1999.33, 1999.42, ....

smooth(scans::Vector{MSscan}; method::MethodType=SG(5, 9, 0))

Smooth the intensity of the input data and returns a similar structure.

Examples

julia> scans = load("filename")
julia> smoothed_data = MSj.smooth(scans)
6-element Array{MSj.MSscan,1}:
 MSj.MSscan(1, 0.1384, 5.08195e6 .....

savitzky_golay_filtering(scan::MSj.MScontainer, order::Int, window::Int, deriv::Int)

Savinsky and Golay filtering of mz and int data within the MSscan(s) container.

centroid(scan::MScontainer; method::MethodType=MethodType=SNRA(1., 100) )

Peak picking algorithm taking a MSscan or MSscans object as input and returning an object of the same type containing the detected peaks. Available algorithm are : Signal to Noise Ratio (SNR) and Template Based Peak Detection (TBPD). Default method is Signal to Noise Ratio Analysis (SNRA), with default threshold = 1.0 and region = 100.

Examples

julia> centroid(scans)
MSscans(1, 0.1384, 5.08195e6, [140.083, 140.167, 140.25, 140.333, 140.417, 140.5, 140.583, 140.667, 140.75, 140.833  …  1999.25, 1999.33, 1999.42, ....

formula(formula::String)

Private function that reads the input chemical formula and sorts the atoms. It returns a dictionary in which the different entries represent the atoms and the values are the number of times the atoms have been found in the formula.

masses(input::String)

Calculates the average, monoistopic and nominal masses for the chemical formula given as an input. The result is returned in a dictionary with the following entries: "Monoiotopic", Average" and "Nominal".

Examples

julia> masses("C254 H377 N65 O75 S6")
Dict("S" => 6,"C" => 254,"N" => 65,"H" => 377,"O" => 75)
Dict{String,Float64} with 3 entries:
  "Monoisotopic" => 5729.6
  "Average"      => 5733.55
  "Nominal"      => 5727.0

masses(f::Dict{String,Int})

Calculates the average, monoistopic and nominal masses for the chemical formula dictionary, such as prodcued by MSj.formula. The result is returned in a dictionary with the following entries: "Monoiotopic", Average" and "Nominal".

Examples

julia> masses("C254 H377 N65 O75 S6")
Dict("S" => 6,"C" => 254,"N" => 65,"H" => 377,"O" => 75)
Dict{String,Float64} with 3 entries:
  "Monoisotopic" => 5729.6
  "Average"      => 5733.55
  "Nominal"      => 5727.0

isotopic_distribution(input::String, p_target::Real; charge::Int = +1, tau::Real = 0.1, Elements::Dict{String,Array{MSj.Isotope,1}} = MSj.Elements)

Calculates the isotopic distribution of input formula for which the overall probabilities equals p_target using the isospec algorithm. The charge state is entered as an optional argument. The peaks detection threshold tau is by default set to 10%.

Examples

julia> isotopic_distribution("C254 H377 N65 O75 S6", 0.5)
Dict("S" => 6,"C" => 254,"N" => 65,"H" => 377,"O" => 75)
9×15 Array{Union{Float64, Int, String},2}:
     "Masses"   "Probability"     "12C"   "13C"   "32S"   "34S"   "33S"   "36S"    "14N"   "15N"    "16O"   "18O"   "17O"     "1H"   "2H"
 5731.61       0.112302        252       2       6       0       0       0       65       0       75       0       0       377      0    
 5732.61       0.102878        251       3       6       0       0       0       65       0       75       0       0       377      0    
 5730.6        0.0814037       253       1       6       0       0       0       65       0       75       0       0       377      0    
 5733.61       0.0704028       250       4       6       0       0       0       65       0       75       0       0       377      0    
 5734.62       0.0383896       249       5       6       0       0       0       65       0       75       0       0       377      0    
 5733.6        0.0301637       252       2       5       1       0       0       65       0       75       0       0       377      0    
 5729.6        0.0293871       254       0       6       0       0       0       65       0       75       0       0       377      0    
 5734.61       0.0276323       251       3       5       1       0       0       65       0       75       0       0       377      0    
``julia> isotopic_distribution("C254 H377 N65 O75 S6", 0.5, charge = +7)
Dict("S" => 6,"C" => 254,"N" => 65,"H" => 377,"O" => 75)
9×15 Array{Union{Float64, Int, String},2}:
    "Masses"   "Probability"     "12C"   "13C"   "32S"   "34S"   "33S"   "36S"    "14N"   "15N"    "16O"   "18O"   "17O"     "1H"   "2H"
 818.801      0.112302        252       2       6       0       0       0       65       0       75       0       0       377      0    
 818.944      0.102878        251       3       6       0       0       0       65       0       75       0       0       377      0    
 818.658      0.0814037       253       1       6       0       0       0       65       0       75       0       0       377      0    
 819.088      0.0704028       250       4       6       0       0       0       65       0       75       0       0       377      0    
 819.231      0.0383896       249       5       6       0       0       0       65       0       75       0       0       377      0    
 819.086      0.0301637       252       2       5       1       0       0       65       0       75       0       0       377      0    
 818.514      0.0293871       254       0       6       0       0       0       65       0       75       0       0       377      0    
 819.23       0.0276323       251       3       5       1       0       0       65       0       75       0       0       377      0    

simulate(I::Array{Union{Float64, Int, String}}, ∆mz::Real; model::Symbol=:gauss, Npoints::Int=1000)

From an isotopic distribution and a peak width returns a mass spectrum (MSScan). The number of points of the resulting mass spectrum is passed as an optional argument. Peak shape are :gauss (default), :lorentz, :voight.

Examples

julia>  a = simulate(I, 0.4)
MSj.MSscan(1, 0.0, 30898.192348114364, [5727.102517458742 ..., "", "", 0.0)

Plotting module for MScontainer data type (MSscan, MSscans and Chromatogram).

julia> plot(scans[1])
julia> plot(chr)

normalisation(cr::MSj.Chromatogram)

Normalization function for plotting chromatograms in raltive intensity.

normalisation(ms::MSj.MScontainer)

Normalization function for plotting mass spectra in relative intensity.

scaling(cr::MSj.Chromatogram)

Scaling function to display retention times of chromatograms in minutes instead of seconds.

h(cr::MSj.Chromatogram; method = :relative)

Allows plotting directly chromatograms. The defaults relative intensity plotting may be changed by setting method = :absolute.

g(ms::MSj.MSscans; method = :relative)

Allows plotting directly mass spectra MSscans. The defaults relative intensity plotting may be changed by setting method = :absolute.

f(ms::MSscan; method = :relative)

Allows plotting directly mass spectra MSscan. The defaults relative intensity plotting may be changed by setting method = :absolute.

+(a::MScontainer, b::MScontainer)

Addition of mass spectra elementwise.

julia> scans[1] - scans[2]
MSj.MSscans([1, 2], [0.1384, 0.7307]

-(a::MScontainer, b::MScontainer)

Substraction of mass spectra elementwise. Negative scan num refers the 'b' MScontainer.

julia> a - b
MSj.MSscans([1, 4], [0.1384, 3.7578, -0.1384, -3.7578]...

/(a::MSscan, N::Real)

Divide the intensity and the tic data of a MSscan by a number.

julia> scans[1] / 1.0e2
MSj.MSscan(1, 0.1384, 50819.5, [140. ....

/(a::MSscans, N::Real)

Divide in the intenisty, tic and variance of a MSscans by a number.

julia> a / 1.0e2
MSj.MSscans(1, 0.1384, 50819.5, [140. ....

*(a::MSscan, N::Real)

Multiply the intensity and the tic data of a MSscan by a number.

julia> scans[1] * 1.0e2
MSj.MSscan(1, 0.1384, 50819.5, [140. ....

*(a::MSscans, N::Real)

Multiply in the intenisty, tic and variance of a MSscans by a number.

julia> a * 1.0e2
MSj.MSscans(1, 0.1384, 50819.5, [140. ....

*(N::Real, a::MScontainer)

Commutation of multiplication of number with MSscontainer.

*(a::MScontainer, b::MScontainer)

Multiplication of mass spectra elementwise.

julia> a * b
MSj.MSscans([2, 5], [0.7307, 4.344

avg(a::MScontainer, b::MScontainer)

Returns the average of the input mass spectra and compute the variance using an incremental Welford algorithm.

julia> MSj.avg(scans[1], scans[4])
MSj.MSscans([1, 4], [0.1384, 3.7578], ....

add_ion_current(x::AbstractArray, y::AbstractArray, a::Real, b::Real)

Returns sum the ion current (int) within the m/z range defined by the a and b input values.

num2pnt(x::AbstractArray, val::Real)

General purpose utility function used to retrieve the index of an array for which the value is closest to the input.

savitzky_golay(int::AbstractArray, order::Int, window::Int, deriv::Int)

Savinsky and Golay filter removes high frequency noise from data. Parameters: int::AbstractArray order::Int order of the polynomial window::Int length of the window, has to be an odd number deriv::Int the order of the derivative to be computed. Default = 0 leads to smoothing only.

extremefilt(input::AbstractArray, minmax::Function, region::Int)

Return the erosion or the dilation of the input over the region, which the size of the structuring element.

morpholaplace(input::AbstractArray, region::Int)

Perfoms morphological Laplacian of the input array, as defined by the addition of the dilatation and the erosion of the input array.

morphogradient(input::AbstractArray, region::Int)

Perfoms morphological Gradient of the input array, defined by the difference between the dilatation and the erosion of the input array.

tophat(input::AbstractArray, region::Int)

Performs the Top Hat of the input Array, defined by the difference between the input and its morphological opening.

bottomhat(input::AbstractArray, region::Int)

Performs the Bottom Hat of the input Array, defined by the difference between the morphological closing of the input and the input.

opening(input::AbstractArray, region::Int)

Performs the morphological opening of the input Array, which is the dilatation of the erosion of the input

closing(input::AbstractArray, region::Int

Performs the morphological closing of the input Array, which is defined as the erosion of the dilatation of the input.

erosion(input::AbstractArray, region::Int)

Performs the morphological erosion of the input, which is the minimum-filtering over the structuring element region.

dilatation(input::AbstractArray, region::Int)

Performs the morphological dilatation of the input, which is the maximum-filtering over the structuring element region

convolve(a::AbstractArray, b::AbstractArray)

Convolve arrays a and b using the Fourier transform algorithm.