private static double? GetPrecursorCollisionEnergy(Precursor precursor) { var param = precursor.activation.cvParam(CVID.MS_collision_energy); if (param.empty()) return null; return (double)param.value; }
private void WritePrecursor(Precursor pc) { writer.WriteStartElement("precursor"); if (pc.SpectrumReference != null) { WriteSpectrumRef(pc.SpectrumReference); } WriteList("selectedIonList", pc.SelectedIons, WriteSelectedIon); if (pc.IsolationWindow != null) { WriteIsolationWindow(pc.IsolationWindow); } if (pc.Activation != null) { writer.WriteStartElement("activation"); WriteParamGroup(pc.Activation); writer.WriteEndElement(); } writer.WriteEndElement(); }
protected int getPrecursorCharge(Spectrum spectrum) { int result = 0; var retryTimes = 3; while (result < 0 && retryTimes > 0) { try { Precursor precursor = spectrum.precursors[0]; if (precursor.selectedIons == null || precursor.selectedIons[0].cvParamChild(CVID.MS_charge_state) .cvid.Equals(CVID.CVID_Unknown)) { return(0); } result = Int32.Parse(precursor.selectedIons[0].cvParamChild(CVID.MS_charge_state).value.ToString()); } catch (FormatException e) { jobInfo.log("Charge-重试次数-" + retryTimes + "-Result:" + result); jobInfo.log(e.StackTrace); } retryTimes--; } if (result < 0) { throw new Exception("Parse Integer Error:" + result); } return(result); }
protected double getPrecursorIsolationWindowParams(Spectrum spectrum, CVID cvid) { double result = -1; var retryTimes = 3; while (result < 0 && retryTimes > 0) { try { Precursor precursor = spectrum.precursors[0]; result = Double.Parse(precursor.isolationWindow.cvParamChild(cvid).value.ToString()); } catch (FormatException e) { jobInfo.log(cvid + "-重试次数-" + retryTimes + "-Result:" + result); jobInfo.log(e.StackTrace); } retryTimes--; } if (result < 0) { throw new Exception("Parse Double Error:" + result); } return(result); }
/// <summary> /// Check and set attribute based on attributes dictionary /// </summary> /// <param name="attribute"></param> /// <param name="value"></param> private void SetAttribute(CVParam cvParam, Scan scan, Precursor precursor) { string member = ""; object o = null; if (scanAttrs.ContainsKey(cvParam.Name)) { member = scanAttrs[cvParam.Name]; o = scan; } else if (precursorAttrs.ContainsKey(cvParam.Name)) { member = precursorAttrs[cvParam.Name]; o = precursor; } if (member == "") { return; } var prop = o.GetType().GetProperty(member); var value = Convert.ChangeType(cvParam.Value, prop.PropertyType); prop.SetValue(o, value); }
/// <summary> /// Open the given file and import scans into the reader. /// </summary> /// <returns></returns> public IEnumerator GetEnumerator() { // Reset to beginning of document. Reader = XmlReader.Create(FilePath); Scan scan = null; while(Reader.Read()) { switch (Reader.NodeType) { case XmlNodeType.Element: if (scan != null && (Reader.Name == "scan" || Reader.Name == "index")) { // mzXML can have nested scans, so returning scans here. yield return scan; } if (Reader.Name == "scan") { scan = new Scan(); while (Reader.MoveToNextAttribute()) { SetAttribute(scan, Reader.Name, Reader.Value); if (Reader.Name == "filterLine") { int spacePos = scan.FilterLine.IndexOf(' '); if (spacePos > 0) { // Setting detector after setting filterLine in SetAttribute() scan.DetectorType = scan.FilterLine.Substring(0, spacePos).ToUpper(); } } } } if (Reader.Name == "peaks" && scan != null) { scan.Centroids = ReadPeaks(Reader.ReadElementContentAsString(), scan.PeakCount); } else if (Reader.Name == "precursorMz" && scan != null) { var precursor = new Precursor(); while (Reader.MoveToNextAttribute()) { if (Reader.Name == "precursorCharge") { precursor.Charge = int.Parse(Reader.Value); } else if(Reader.Name == "precursorIntensity") { precursor.Intensity = double.Parse(Reader.Value); } else if(Reader.Name == "isolationWidth") { precursor.IsolationWidth = double.Parse(Reader.Value); } else if(Reader.Name == "isolationMz") { precursor.IsolationMz = double.Parse(Reader.Value); } else { SetAttribute(scan, Reader.Name, Reader.Value); } } Reader.MoveToContent(); precursor.Mz = double.Parse(Reader.ReadElementContentAsString()); precursor.OriginalMz = precursor.Mz; precursor.OriginalCharge = precursor.Charge; scan.Precursors.Add(precursor); } break; default: break; } } }
public Precursor(Precursor precursor) { Mz = precursor.Mz; Intensity = precursor.Intensity; Charge = precursor.Charge; OriginalMz = precursor.OriginalMz; OriginalCharge = precursor.OriginalCharge; IsolationMz = precursor.IsolationMz; IsolationWidth = precursor.IsolationWidth; IsolationSpecificity = precursor.IsolationSpecificity; }
private List <Protein> GetProteinsFromSkyline() { var result = new List <Protein>(); IReport reportTrackINTargets = _toolClient.GetReport("BLR TrackIN Targets"); var ProteinsQ = from reportRow in reportTrackINTargets.Cells where string.IsNullOrEmpty(reportRow[0]) != true group reportRow by reportRow[0] into ProteintGroup select new { Protein = ProteintGroup.Key, Peptides = from reportRow in ProteintGroup group reportRow by reportRow[1] into PeptideGroup select new { Peptide = PeptideGroup.Key, Precursors = from reportRow in PeptideGroup group reportRow by new { Isotope = reportRow[2], Precursor = reportRow[3] } into PrecursorGroup select new { Isotope = PrecursorGroup.Key.Isotope, PrecursorMZ = PrecursorGroup.Key.Precursor, ProductMZ = from reportRow in PrecursorGroup select reportRow[4] } } }; foreach (var prot in ProteinsQ) { Protein protein = new Protein(); protein.Name = prot.Protein; foreach (var pept in prot.Peptides) { Peptide peptide = new Peptide(); peptide.Name = pept.Peptide; foreach (var prec in pept.Precursors) { Precursor precursor = new Precursor(); precursor.IsotopeLabelType = prec.Isotope; precursor.PrecursorMZ = Convert.ToDouble(prec.PrecursorMZ); foreach (var prod in prec.ProductMZ) { precursor.Products.Add(Convert.ToDouble(prod)); } peptide.Precursors.Add(precursor); } protein.Peptides.Add(peptide); } result.Add(protein); } return(result); }
/// <summary> /// Overload to handle all available scans allowing for Ms1 inclusion of before + after /// </summary> /// <param name="AllScans"></param> /// <param name="DependentScan"></param> /// <param name="Number_Of_Scans_To_Average"></param> public static void Run(ref List <Scan> scans, MonocleOptions Options) { foreach (Scan scan in scans) { if (scan.MsOrder != Options.MS_Level) { continue; } if (scan.PrecursorMasterScanNumber <= 0) { Console.WriteLine(String.Format("Scan {0} does not have a precursor scan number assigned.", scan.ScanNumber)); continue; } Scan precursorScan = scans[scan.PrecursorMasterScanNumber - 1]; var nearbyScans = GetNearbyScans(ref scans, precursorScan, Options); // For low-res scans, or if ForceCharges is true, generate precursors with // a range of charges given by the ChargeRangeUnknown option. bool lowResPrecursor = precursorScan.FilterLine.Contains("ITMS"); if (lowResPrecursor || Options.ForceCharges) { int range = 1 + Options.ChargeRangeUnknown.High - Options.ChargeRangeUnknown.Low; var precursors = new List <Precursor>(range); foreach (var precursor in scan.Precursors) { for (int z = Options.ChargeRangeUnknown.Low; z <= Options.ChargeRangeUnknown.High; ++z) { var p = new Precursor(precursor); p.Charge = z; precursors.Add(p); } } scan.Precursors = precursors; } if (!Options.SkipMono && !lowResPrecursor) { foreach (var precursor in scan.Precursors) { if (!Options.Charge_Detection && precursor.Charge == 0) { Console.WriteLine(String.Format("Scan {0} does not have a charge state assigned. Charge detection enabled.", scan.ScanNumber)); } Run(nearbyScans, precursorScan, precursor, Options); } } } }
public override int GetHashCode() { unchecked { var hashCode = (Client != null ? Client.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (IntensityModel != null ? IntensityModel.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (RTModel != null ? RTModel.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Settings != null ? Settings.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Precursor != null ? Precursor.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Peptide != null ? Peptide.GetHashCode() : 0); hashCode = (hashCode * 397) ^ NCE; return(hashCode); } }
public TransitionGroupDocNode UpdatePrecursor(IdentityPath parent, TransitionGroupDocNode precursorDocNode) { CheckCancelled(); AnnotationUpdater updater; _annotationUpdaters.TryGetValue(AnnotationDef.AnnotationTarget.precursor, out updater); IdentityPath identityPath = new IdentityPath(parent, precursorDocNode.TransitionGroup); if (updater != null || _precursorResultUpdater != null) { var precursor = new Precursor(SkylineDataSchema, identityPath); if (updater != null) { var annotations = updater.UpdateAnnotations(precursorDocNode.Annotations, precursor); if (!Equals(annotations, precursorDocNode.Annotations)) { precursorDocNode = (TransitionGroupDocNode)precursorDocNode.ChangeAnnotations(annotations); } } if (_precursorResultUpdater != null) { var newResults = _precursorResultUpdater.Update(precursorDocNode.Results, precursor.Results); precursorDocNode = precursorDocNode.ChangeResults(newResults); } } if (!RecurseTransitions) { return(precursorDocNode); } var newChildren = precursorDocNode.Transitions .Select(transition => UpdateTransition(identityPath, transition)).ToArray(); if (!ArrayUtil.ReferencesEqual(precursorDocNode.Children, newChildren)) { precursorDocNode = (TransitionGroupDocNode)precursorDocNode.ChangeChildren(newChildren); } return(precursorDocNode); }
/// <summary> /// Run a single Monocle scan. /// </summary> /// <param name="Ms1ScansCentroids"></param> /// <param name="ParentScan"></param> /// <param name="precursor"></param> public static void Run(List <Scan> Ms1ScansCentroids, Scan ParentScan, Precursor precursor, MonocleOptions Options) { double precursorMz = precursor.IsolationMz; if (precursorMz < 1) { precursorMz = precursor.Mz; } int precursorCharge = precursor.Charge; if (Options.UseMostIntense && precursor.IsolationWidth > 0) { // Re-assign the precursor m/z to that of the most intense peak in the isolation window. int peakIndex = PeakMatcher.MostIntenseIndex(ParentScan, precursor.IsolationMz, precursor.IsolationWidth / 2, PeakMatcher.DALTON); if (peakIndex >= 0) { precursorMz = ParentScan.Centroids[peakIndex].Mz; } } // Search for ion in parent scan, use parent ion mz for future peaks int index = PeakMatcher.Match(ParentScan, precursorMz, 50, PeakMatcher.PPM); if (index >= 0) { precursorMz = ParentScan.Centroids[index].Mz; } // For charge detection int bestCharge = 0; double bestScore = -1; int bestIndex = 0; List <double> bestPeaks = new List <double>(); List <double> bestPeakIntensities = new List <double>(); //Create new class to maintain ref class options ChargeRange chargeRange = new ChargeRange(precursorCharge, precursorCharge); if (Options.Charge_Detection || precursorCharge == 0) { chargeRange.Low = Options.Charge_Range.Low; chargeRange.High = Options.Charge_Range.High; } for (int charge = chargeRange.Low; charge <= chargeRange.High; charge++) { // Restrict number of isotopes to consider based on precursor mass. double mass = precursor.Mz * charge; var isotopeRange = new IsotopeRange(mass); // Generate expected relative intensities. List <double> expected = PeptideEnvelopeCalculator.GetTheoreticalEnvelope(precursorMz, charge, isotopeRange.CompareSize); Vector.Scale(expected); PeptideEnvelope envelope = PeptideEnvelopeExtractor.Extract(Ms1ScansCentroids, precursorMz, charge, isotopeRange.Left, isotopeRange.Isotopes); // Get best match using dot product. // Limit the number of isotopeRange peaks to test for (int i = 0; i < (isotopeRange.Isotopes - (isotopeRange.CompareSize - 1)); ++i) { List <double> observed = envelope.averageIntensity.GetRange(i, expected.Count); Vector.Scale(observed); PeptideEnvelopeExtractor.ScaleByPeakCount(observed, envelope, i); double score = Vector.Dot(observed, expected); // add 5% to give bias toward left peaks. if (score > bestScore * 1.05) { bestScore = score; if (score > 0.1) { // A peak to the left is included, so add // offset to get monoisotopic index. bestIndex = i + 1; bestCharge = charge; bestPeaks = envelope.mzs[bestIndex]; bestPeakIntensities = envelope.intensities[bestIndex]; } } } } // end charge for loop if (bestCharge > 0) { precursor.Charge = bestCharge; } // Calculate m/z if (bestPeaks.Count > 0) { precursor.Mz = Vector.WeightedAverage(bestPeaks, bestPeakIntensities); } else { precursor.Mz = precursorMz; } precursor.IsolationSpecificity = IsolationSpecificityCalculator.calculate( ParentScan.Centroids, precursor.IsolationMz, precursor.Mz, precursor.Charge, precursor.IsolationWidth ); }
public Transitions(Precursor precursor) : base(precursor.DataSchema, precursor.IdentityPath) { }
private static double? GetIsolationWindowValue(Precursor precursor, CVID cvid) { var term = precursor.isolationWindow.cvParam(cvid); if (!term.empty()) return term.value; return null; }
public PrecursorResultList(Precursor precursor) : base(precursor.DataSchema) { Precursor = precursor; OnDocumentChanged(); }
public PrecursorResult(Precursor precursor, ResultFile file) : base(precursor, file) { _chromInfo = CachedValue.Create(DataSchema, ()=>GetResultFile().FindChromInfo(precursor.DocNode.Results)); }
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 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 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> /// Open the given file and import scans into the reader. /// </summary> /// <returns></returns> public IEnumerator GetEnumerator() { // Reset to beginning of document. Reader = XmlReader.Create(FilePath); Scan scan = null; Precursor precursor = null; var binaryData = new BinaryData(); while (Reader.Read()) { if (Reader.NodeType == XmlNodeType.Element) { if (Reader.Name == "spectrum") { // Using spectrum as a start of scan. // <spectrum index="11" defaultArrayLength="113" id="index=12"> // Using id attr for scan numbers scan = new Scan(); ReadSpectrumAttrs(scan); } else if (Reader.Name == "precursor") { // Precursor contains the precursor scan number. // <precursor spectrumRef="index=11"> } else if (Reader.Name == "selectedIon") { precursor = new Precursor(); } else if (Reader.Name == "cvParam") { var cvParam = ReadCVParam(); SetAttribute(cvParam, scan, precursor); } else if (Reader.Name == "binaryDataArray") { ReadBinaryData(binaryData, scan.PeakCount); } } else if (Reader.NodeType == XmlNodeType.EndElement) { // Reached a closing tag. if (Reader.Name == "spectrum") { scan.Centroids.Clear(); for (int i = 0; i < scan.PeakCount; ++i) { scan.Centroids.Add( new Centroid( binaryData.mzs[i], binaryData.intensities[i]) ); } yield return(scan); } if (Reader.Name == "selectedIon") { scan.Precursors.Add(precursor); } else if (Reader.Name == "spectrumList") { break; } } } }
public IEnumerator GetEnumerator() { var scanCommand = new SQLiteCommand("SELECT * FROM scans AS s LEFT JOIN scan_peaks as p ON p.scan=s.scan", db); var precursorCommand = new SQLiteCommand("SELECT * FROM scan_precursors WHERE scan=$scan", db); using (var scanReader = scanCommand.ExecuteReader()) { while (scanReader.Read()) { int foo = (int)scanReader["scan"]; var scan = new Scan { ScanNumber = (int)scanReader["scan"], ScanEvent = (int)scanReader["scan_event"], MsOrder = (int)scanReader["ms_level"], PeakCount = (int)scanReader["peak_count"], MasterIndex = (int)scanReader["master_index"], IonInjectionTime = (double)scanReader["ion_injection_time"], ElapsedScanTime = (double)scanReader["elapsed_scan_time"], Polarity = ReadPolarity((string)scanReader["polarity"]), ScanType = (string)scanReader["scan_type"], DetectorType = (string)scanReader["detector_type"], FilterLine = (string)scanReader["filter_line"], RetentionTime = (double)scanReader["time"], StartMz = (double)scanReader["start_mz"], EndMz = (double)scanReader["end_mz"], LowestMz = (double)scanReader["low_mz"], HighestMz = (double)scanReader["high_mz"], BasePeakMz = (double)scanReader["base_peak_mz"], BasePeakIntensity = (double)scanReader["base_peak_intensity"], FaimsCV = (int)(double)scanReader["cv"], TotalIonCurrent = (double)scanReader["total_intensity"], CollisionEnergy = (double)scanReader["activation_energy"], PrecursorMasterScanNumber = (int)scanReader["parent_scan"], PrecursorActivationMethod = (string)scanReader["activation_type"] }; int peakFlags = (int)scanReader["data_type"]; if (peakFlags > 0) { byte[] data = (byte[])scanReader["data"]; if (compression == "zlib") { data = DecompressData(data); } DecodePeaks(scan, peakFlags, data); } precursorCommand.Parameters.AddWithValue("$scan", scan.ScanNumber); using (var precursorReader = precursorCommand.ExecuteReader()) { while (precursorReader.Read()) { Precursor precursor = new Precursor() { Mz = (double)precursorReader["precursor_mz"], Intensity = (double)precursorReader["precursor_intensity"], Charge = (int)precursorReader["precursor_charge"], OriginalMz = (double)precursorReader["original_mz"], OriginalCharge = (int)precursorReader["original_charge"], IsolationMz = (double)precursorReader["isolation_mz"], IsolationWidth = (double)precursorReader["isolation_width"], IsolationSpecificity = (double)precursorReader["isolation_specificity"] }; scan.Precursors.Add(precursor); } } yield return(scan); } } }
public PrecursorResultList(Precursor precursor) : base(precursor.DataSchema) { Precursor = precursor; }
private static double? GetPrecursorMz(Precursor precursor) { // CONSIDER: Only the first selected ion m/z is considered for the precursor m/z var selectedIon = precursor.selectedIons.FirstOrDefault(); if (selectedIon == null) return null; return selectedIon.cvParam(CVID.MS_selected_ion_m_z).value; }
private const string USERPARAM_DRIFT_TIME = "drift time"; // Not L10N private static double? GetPrecursorDriftTimeMsec(Precursor precursor) { UserParam param = precursor.userParam(USERPARAM_DRIFT_TIME); // CONSIDER: this will eventually be a proper CVParam if (param.empty()) return null; return param.timeInSeconds() * 1000.0; }
/// <summary> /// Overload to handle all available scans allowing for Ms1 inclusion of before + after /// </summary> /// <param name="AllScans"></param> /// <param name="DependentScan"></param> /// <param name="Number_Of_Scans_To_Average"></param> public static void Run(ref List <Scan> scans, MonocleOptions Options) { if (Options.Ms2Ms3Precursor) { AssignMs3Precursors(scans); } CheckMs2Precursors(scans); foreach (Scan scan in scans) { if (scan.MsOrder != Options.MS_Level) { continue; } if (scan.PrecursorMasterScanNumber <= 0) { Console.WriteLine(String.Format("Scan {0} does not have a precursor scan number assigned.", scan.ScanNumber)); continue; } Scan precursorScan = scans[scan.PrecursorMasterScanNumber - 1]; // For low-res scans, or if ForceCharges is true, or if there's no charge information // and monoisotopic peak detection is disabled, generate precursors with // a range of charges given by the ChargeRangeUnknown option. bool lowResPrecursor = precursorScan.FilterLine.Contains("ITMS"); int range = 1 + Options.ChargeRangeUnknown.High - Options.ChargeRangeUnknown.Low; var precursors = new List <Precursor>(range); foreach (var precursor in scan.Precursors) { if (lowResPrecursor || Options.ForceCharges || (precursor.Charge == 0 && Options.SkipMono)) { for (int z = Options.ChargeRangeUnknown.Low; z <= Options.ChargeRangeUnknown.High; ++z) { var p = new Precursor(precursor); p.Charge = z; precursors.Add(p); } } } if (precursors.Count > 0) { scan.Precursors = precursors; } if (!Options.SkipMono && !lowResPrecursor) { var nearbyScans = GetNearbyScans(ref scans, precursorScan, Options); precursors = new List <Precursor>(); foreach (var precursor in scan.Precursors) { if (!Options.Charge_Detection && precursor.Charge == 0) { // Charge detection will be enabled in the Run method. Console.WriteLine(String.Format("Scan {0} does not have a charge state assigned. Charge detection enabled.", scan.ScanNumber)); } Run(nearbyScans, precursorScan, precursor, Options); // If there is still no charge, use charge range. if (precursor.Charge == 0) { Console.WriteLine(String.Format("No charge found for scan {0}. Using charge range.", scan.ScanNumber)); for (int z = Options.ChargeRangeUnknown.Low; z <= Options.ChargeRangeUnknown.High; ++z) { var p = new Precursor(precursor); p.Charge = z; precursors.Add(p); } } else { precursors.Add(precursor); } } scan.Precursors = precursors; } } }