/// <summary> /// Mass-to-charge ratio of a precursor ion selected for fragmentation. [PSI:PI] /// </summary> public static SelectedIon SetSelectedIonMz( this SelectedIon si, double mz) { if (mz < 0) { throw new ArgumentOutOfRangeException("mz"); } return(si.SetCvParam(SelectedIonMz, mz).PSIMS_Mz()); }
/// <summary> /// Mass-to-charge ratio of a precursor ion selected for fragmentation. [PSI:PI] /// </summary> public static bool TryGetSelectedIonMz( this SelectedIon si, out double mz) { CvParam p; if (si.TryGetParam(SelectedIonMz, out p)) { mz = p.GetDouble(); return(true); } else { mz = default(double); return(false); } }
private MzLite.Model.MassSpectrum ReadMassSpectrum(int scanNo) { RaiseDisposed(); try { string spectrumID = GetSpectrumID(scanNo); MassSpectrum spectrum = new MassSpectrum(spectrumID); // spectrum int msLevel = GetMSLevel(rawFile, scanNo); spectrum.SetMsLevel(msLevel); if (IsCentroidSpectrum(rawFile, scanNo)) { spectrum.SetCentroidSpectrum(); } else { spectrum.SetProfileSpectrum(); } // scan Scan scan = new Scan(); scan.SetFilterString(GetFilterString(rawFile, scanNo)) .SetScanStartTime(GetRetentionTime(rawFile, scanNo)); //.UO_Minute(); spectrum.Scans.Add(scan); // precursor if (msLevel > 1) { Precursor precursor = new Precursor(); double isoWidth = GetIsolationWindowWidth(rawFile, scanNo, msLevel) * 0.5d; double targetMz = GetIsolationWindowTargetMz(rawFile, scanNo, msLevel); double precursorMz = GetPrecursorMz(rawFile, scanNo, msLevel); int chargeState = GetChargeState(rawFile, scanNo); precursor.IsolationWindow .SetIsolationWindowTargetMz(targetMz) .SetIsolationWindowUpperOffset(isoWidth) .SetIsolationWindowLowerOffset(isoWidth); SelectedIon selectedIon = new SelectedIon(); selectedIon .SetSelectedIonMz(precursorMz) .SetChargeState(chargeState); precursor.SelectedIons.Add(selectedIon); spectrum.Precursors.Add(precursor); } return(spectrum); } catch (Exception ex) { throw new MzLiteIOException(ex.Message, ex); } }
private static MzLite.Model.MassSpectrum GetSpectrum( Batch batch, MassSpectrometerSample sample, MSExperiment msExp, int sampleIndex, int experimentIndex, int scanIndex) { MassSpectrumInfo wiffSpectrum = msExp.GetMassSpectrumInfo(scanIndex); MzLite.Model.MassSpectrum mzLiteSpectrum = new Model.MassSpectrum(ToSpectrumID(sampleIndex, experimentIndex, scanIndex)); // spectrum mzLiteSpectrum.SetMsLevel(wiffSpectrum.MSLevel); if (wiffSpectrum.CentroidMode) { mzLiteSpectrum.SetCentroidSpectrum(); } else { mzLiteSpectrum.SetProfileSpectrum(); } // scan Scan scan = new Scan(); scan.SetScanStartTime(wiffSpectrum.StartRT) .UO_Minute(); mzLiteSpectrum.Scans.Add(scan); // precursor if (wiffSpectrum.IsProductSpectrum) { Precursor precursor = new Precursor(); double isoWidth; double targetMz; if (GetIsolationWindow(wiffSpectrum.Experiment, out isoWidth, out targetMz)) { precursor.IsolationWindow .SetIsolationWindowTargetMz(targetMz) .SetIsolationWindowUpperOffset(isoWidth) .SetIsolationWindowLowerOffset(isoWidth); } SelectedIon selectedIon = new SelectedIon(); selectedIon.SetSelectedIonMz(wiffSpectrum.ParentMZ) .SetChargeState(wiffSpectrum.ParentChargeState); precursor.SelectedIons.Add(selectedIon); precursor.Activation .SetCollisionEnergy(wiffSpectrum.CollisionEnergy); mzLiteSpectrum.Precursors.Add(precursor); } return(mzLiteSpectrum); }
/// <summary> /// Handle a single selectedIonList element and child nodes /// Called by ReadPrecursor (xml hierarchy) /// </summary> /// <param name="reader">XmlReader that is only valid for the scope of the single selectedIonList element</param> /// <returns></returns> private List<SelectedIon> ReadSelectedIonList(XmlReader reader) { reader.MoveToContent(); //int count = Convert.ToInt32(reader.GetAttribute("count")); var ions = new List<SelectedIon>(); reader.ReadStartElement("selectedIonList"); // Throws exception if we are not at the "selectedIonList" tag. while (reader.ReadState == ReadState.Interactive) { // Handle exiting out properly at EndElement tags if (reader.NodeType != XmlNodeType.Element) { reader.Read(); continue; } switch (reader.Name) { case "selectedIon": // Schema requirements: one to many instances of this element var ion = new SelectedIon(); var innerReader = reader.ReadSubtree(); innerReader.MoveToContent(); innerReader.ReadStartElement("selectedIon"); // Throws exception if we are not at the "selectedIon" tag. while (innerReader.ReadState == ReadState.Interactive) { // Handle exiting out properly at EndElement tags if (innerReader.NodeType != XmlNodeType.Element) { innerReader.Read(); continue; } switch (innerReader.Name) { case "referenceableParamGroupRef": // Schema requirements: zero to many instances of this element innerReader.Skip(); break; case "cvParam": // Schema requirements: zero to many instances of this element /* 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) */ switch (innerReader.GetAttribute("accession")) { case "MS:1000041": // name="charge state" ion.Charge = (int)Convert.ToDouble(innerReader.GetAttribute("value")); break; case "MS:1000744": // name="selected ion m/z" ion.SelectedIonMz = Convert.ToDouble(innerReader.GetAttribute("value")); break; } innerReader.Read(); // Consume the cvParam element (no child nodes) break; case "userParam": // Schema requirements: zero to many instances of this element if (innerReader.GetAttribute("name") == "old charge state") { ion.OldCharge = (int) Convert.ToDouble(innerReader.GetAttribute("value")); } innerReader.Read(); break; default: innerReader.Skip(); break; } } innerReader.Close(); ions.Add(ion); reader.Read(); // "selectedIon" might not have child nodes // We will either consume the EndElement, or the same element that was passed to ReadSpectrum (in case of no child nodes) break; default: reader.Skip(); break; } } reader.Close(); return ions; }
/// <summary> /// Handle a single spectrum element and child nodes /// Called by ReadSpectrumList (xml hierarchy) /// </summary> /// <param name="reader">XmlReader that is only valid for the scope of the single spectrum element</param> /// <param name="includePeaks">Whether to read binary data arrays</param> private Spectrum ReadSpectrum(XmlReader reader, bool includePeaks = true) { reader.MoveToContent(); string index = reader.GetAttribute("index"); //Console.WriteLine("Reading spectrum indexed by " + index); // This is correct for Thermo files converted by msConvert, but need to implement for others as well string spectrumId = reader.GetAttribute("id"); // Native ID in mzML_1.1.0; unique identifier in mzML_1.0.0, often same as nativeID string nativeId = spectrumId; if (_version == MzML_Version.mzML1_0_0) { nativeId = reader.GetAttribute("nativeID"); // Native ID in mzML_1.0.0 } int scanNum = -1; // If a random access reader, there is already a scan number stored, based on the order of the index. Use it instead. if (_randomAccess) { scanNum = (int) (_spectrumOffsets.NativeToIdMap[nativeId]); } else { scanNum = (int)(_artificialScanNum++); // Interpret the NativeID (if the format has an interpreter) and use it instead of the artificial number. // TODO: Better handling than the artificial ID for other nativeIDs (ones currently not supported) int num = 0; if (NativeIdConversion.TryGetScanNumberInt(nativeId, out num)) { scanNum = num; } } int defaultArraySize = Convert.ToInt32(reader.GetAttribute("defaultArrayLength")); reader.ReadStartElement("spectrum"); // Throws exception if we are not at the "spectrum" tag. bool is_ms_ms = false; int msLevel = 0; bool centroided = false; double tic = 0; List<Precursor> precursors = new List<Precursor>(); List<ScanData> scans = new List<ScanData>(); List<BinaryDataArray> bdas = new List<BinaryDataArray>(); while (reader.ReadState == ReadState.Interactive) { // Handle exiting out properly at EndElement tags if (reader.NodeType != XmlNodeType.Element) { reader.Read(); continue; } ////////////////////////////////////////////////////////////////////////////////////// /// /// MS1 Spectra: only need Spectrum data: scanNum, MSLevel, ElutionTime, mzArray, IntensityArray /// /// MS2 Spectra: use ProductSpectrum; adds ActivationMethod and IsolationWindow /// ////////////////////////////////////////////////////////////////////////////////////// switch (reader.Name) { case "referenceableParamGroupRef": // Schema requirements: zero to many instances of this element reader.Skip(); break; case "cvParam": // Schema requirements: zero to many instances of this element /* 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:1000579 (MS1 spectrum) * e.g.: MS:1000580 (MSn spectrum) * e.g.: MS:1000581 (CRM spectrum) * e.g.: MS:1000582 (SIM spectrum) * e.g.: MS:1000583 (SRM spectrum) * e.g.: MS:1000620 (PDA spectrum) * e.g.: MS:1000627 (selected ion current chromatogram) * 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. */ switch (reader.GetAttribute("accession")) { case "MS:1000127": // name="centroid spectrum" centroided = true; break; case "MS:1000128": // name="profile spectrum" centroided = false; break; case "MS:1000511": // name="ms level" msLevel = Convert.ToInt32(reader.GetAttribute("value")); break; case "MS:1000579": // name="MS1 spectrum" is_ms_ms = false; break; case "MS:1000580": // name="MSn spectrum" is_ms_ms = true; break; case "MS:1000285": // name="total ion current" tic = Convert.ToDouble(reader.GetAttribute("value")); break; } reader.Read(); // Consume the cvParam element (no child nodes) break; case "userParam": // Schema requirements: zero to many instances of this element reader.Skip(); break; case "spectrumDescription": // mzML_1.0.0 compatibility // Schema requirements: one instance of this element ReadSpectrumDescription(reader.ReadSubtree(), ref scans, ref precursors, out centroided); reader.ReadEndElement(); // "spectrumDescription" must have child nodes break; case "scanList": // Schema requirements: zero to one instances of this element scans.AddRange(ReadScanList(reader.ReadSubtree())); reader.ReadEndElement(); // "scanList" must have child nodes break; case "precursorList": // Schema requirements: zero to one instances of this element precursors.AddRange(ReadPrecursorList(reader.ReadSubtree())); reader.ReadEndElement(); // "precursorList" must have child nodes break; case "productList": // Schema requirements: zero to one instances of this element reader.Skip(); break; case "binaryDataArrayList": // Schema requirements: zero to one instances of this element if (includePeaks) { bdas.AddRange(ReadBinaryDataArrayList(reader.ReadSubtree(), defaultArraySize)); reader.ReadEndElement(); // "binaryDataArrayList" must have child nodes } else { reader.Skip(); } break; default: reader.Skip(); break; } } reader.Close(); // Process the spectrum data ScanData scan = new ScanData(); Spectrum spectrum; BinaryDataArray mzs = new BinaryDataArray(); BinaryDataArray intensities = new BinaryDataArray(); foreach (var bda in bdas) { if (bda.ArrayType == ArrayType.m_z_array) { mzs = bda; } else if (bda.ArrayType == ArrayType.intensity_array) { intensities = bda; } } if (!centroided && includePeaks) { // Centroid spectrum // ProteoWizard var centroider = new Centroider(mzs.Data, intensities.Data); double[] centroidedMzs, centroidedIntensities; centroider.GetCentroidedData(out centroidedMzs, out centroidedIntensities); mzs.Data = centroidedMzs; intensities.Data = centroidedIntensities; } if (scans.Count == 1) { scan = scans[0]; } else if (scans.Count > 1) { // TODO: Should do something else to appropriately handle combinations... scan = scans[0]; } if (is_ms_ms) { Precursor precursor = new Precursor(); if (precursors.Count == 1) { precursor = precursors[0]; } else if (precursors.Count > 1) { // TODO: Should do something else to appropriately handle multiple precursors... precursor = precursors[0]; } SelectedIon ion = new SelectedIon(); if (precursor.Ions.Count == 1) { ion = precursor.Ions[0]; } else if (precursor.Ions.Count > 1) { // TODO: Should do something else to appropriately handle multiple selected ions... ion = precursor.Ions[0]; } var pspectrum = new ProductSpectrum(mzs.Data, intensities.Data, scanNum); pspectrum.ActivationMethod = precursor.Activation; // Select mz value to use based on presence of a Thermo-specific user param. // The user param has a slightly higher precision, if that matters. double mz = scan.MonoisotopicMz == 0.0 ? ion.SelectedIonMz : scan.MonoisotopicMz; pspectrum.IsolationWindow = new IsolationWindow(precursor.IsolationWindowTargetMz, precursor.IsolationWindowLowerOffset, precursor.IsolationWindowUpperOffset, mz, ion.Charge); //pspectrum.IsolationWindow.OldCharge = ion.OldCharge; //pspectrum.IsolationWindow.SelectedIonMz = ion.SelectedIonMz; spectrum = pspectrum; } else { spectrum = new Spectrum(mzs.Data, intensities.Data, scanNum); } spectrum.MsLevel = msLevel; spectrum.ElutionTime = scan.StartTime; spectrum.NativeId = nativeId; spectrum.TotalIonCurrent = tic; return spectrum; }
/// <summary> /// The charge state of the ion, single or multiple and positive or negatively charged. [PSI:MS] /// </summary> public static SelectedIon SetChargeState( this SelectedIon si, int state) { return(si.SetCvParam(ChargeState, state).NoUnit()); }
private MassSpectrum ReadMassSpectrum(UInt64 spectrumId) { BafSqlSpectrum bafSpec = linq2BafSql.GetBafSqlSpectrum(this.linq2BafSql.Core, spectrumId); if (bafSpec == null) { throw new MzLiteIOException("No spectrum found for id: " + spectrumId); } MassSpectrum ms = new MassSpectrum(spectrumId.ToString()); // determine ms level BafSqlAcquisitionKey aqKey = linq2BafSql.GetBafSqlAcquisitionKey(this.linq2BafSql.Core, bafSpec.AcquisitionKey); Nullable <int> msLevel = null; if (aqKey != null && aqKey.MsLevel.HasValue) { // bruker starts ms level by 0, must be added by 1 msLevel = aqKey.MsLevel.Value + 1; ms.SetMsLevel(msLevel.Value); } // determine type of spectrum and read peak data // if profile data available we prefer to get profile data otherwise centroided data (line spectra) if (bafSpec.ProfileMzId.HasValue && bafSpec.ProfileIntensityId.HasValue) { ms.SetProfileSpectrum(); } else if (bafSpec.LineMzId.HasValue && bafSpec.LineIntensityId.HasValue) { ms.SetCentroidSpectrum(); } if (msLevel == 1) { ms.SetMS1Spectrum(); } else if (msLevel > 1) { ms.SetMSnSpectrum(); } // scan if (bafSpec.Rt.HasValue) { Scan scan = new Scan(); scan.SetScanStartTime(bafSpec.Rt.Value).UO_Second(); ms.Scans.Add(scan); } // precursor if (msLevel > 1) { SpectrumVariableCollection spectrumVariables = SpectrumVariableCollection.ReadSpectrumVariables(linq2BafSql, bafSpec.Id); Precursor precursor = new Precursor(); decimal value; if (spectrumVariables.TryGetValue("Collision_Energy_Act", supportedVariables, out value)) { precursor.Activation.SetCollisionEnergy(Decimal.ToDouble(value)); } if (spectrumVariables.TryGetValue("MSMS_IsolationMass_Act", supportedVariables, out value)) { precursor.IsolationWindow.SetIsolationWindowTargetMz(Decimal.ToDouble(value)); } if (spectrumVariables.TryGetValue("Quadrupole_IsolationResolution_Act", supportedVariables, out value)) { double width = Decimal.ToDouble(value) * 0.5d; precursor.IsolationWindow.SetIsolationWindowUpperOffset(width); precursor.IsolationWindow.SetIsolationWindowLowerOffset(width); } Nullable <int> charge = null; if (spectrumVariables.TryGetValue("MSMS_PreCursorChargeState", supportedVariables, out value)) { charge = Decimal.ToInt32(value); } IEnumerable <BafSqlStep> ions = linq2BafSql.GetBafSqlSteps(this.linq2BafSql.Core, bafSpec.Id); foreach (BafSqlStep ion in ions) { if (ion.Mass.HasValue) { SelectedIon selectedIon = new SelectedIon(); precursor.SelectedIons.Add(selectedIon); selectedIon.SetSelectedIonMz(ion.Mass.Value); selectedIon.SetUserParam("Number", ion.Number.Value); selectedIon.SetUserParam("IsolationType", ion.IsolationType.Value); selectedIon.SetUserParam("ReactionType", ion.ReactionType.Value); selectedIon.SetUserParam("MsLevel", ion.MsLevel.Value); if (charge.HasValue) { selectedIon.SetChargeState(charge.Value); } } } // set parent spectrum as reference if (bafSpec.Parent.HasValue) { precursor.SpectrumReference = new SpectrumReference(bafSpec.Parent.ToString()); } ms.Precursors.Add(precursor); } return(ms); }
private void WriteSelectedIon(SelectedIon ion) { writer.WriteStartElement("selectedIon"); WriteParamGroup(ion); writer.WriteEndElement(); }