public static void AggregateMetaData(this ScanMetaDataCollection metaData, RawDataCollection rawData, IRawDataPlus rawFile) { List <Operations> operations = new List <Operations>() { Operations.ScanIndex, Operations.MethodData, Operations.RetentionTimes, Operations.TrailerExtras, Operations.PrecursorScans }; if (rawData.methodData.MassAnalyzers[MSOrderType.Ms] == MassAnalyzerType.MassAnalyzerFTMS) { operations.Add(Operations.Ms1CentroidStreams); } else { operations.Add(Operations.Ms1SegmentedScans); } if (rawData.methodData.MassAnalyzers[MSOrderType.Ms2] == MassAnalyzerType.MassAnalyzerFTMS) { operations.Add(Operations.Ms2CentroidStreams); } else { operations.Add(Operations.Ms2SegmentedScans); } if (rawData.methodData.AnalysisOrder == MSOrderType.Ms3) { if (rawData.methodData.MassAnalyzers[MSOrderType.Ms3] == MassAnalyzerType.MassAnalyzerFTMS) { operations.Add(Operations.Ms3CentroidStreams); } else { operations.Add(Operations.Ms3SegmentedScans); } } rawData.Check(rawFile, operations); ProgressIndicator progress = new ProgressIndicator(rawData.scanIndex.ScanEnumerators[MSOrderType.Any].Count(), "Formatting scan meta data"); // add a new ScanMetaData class for each scan foreach (int scan in rawData.scanIndex.ScanEnumerators[MSOrderType.Any]) { metaData.Add(scan, new ScanMetaData()); } // get isolation window double isoWindow; if (rawData.methodData.AnalysisOrder == MSOrderType.Ms2) { isoWindow = rawData.methodData.IsolationWindow.MS2; } else { isoWindow = rawData.methodData.IsolationWindow.MS3.MS1Window; } // get topN foreach (int scan in rawData.scanIndex.ScanEnumerators[MSOrderType.Ms]) { // if the ms1 scan has no scan dependents then topN = 0 if (rawFile.GetScanDependents(scan, 0) == null) { metaData[scan].MS2ScansPerCycle = 0; } else { metaData[scan].MS2ScansPerCycle = rawFile.GetScanDependents(scan, 0).ScanDependentDetailArray.Length; } } // go through scans for each ms order sequentially foreach (MSOrderType MSOrder in new List <MSOrderType> { MSOrderType.Ms, MSOrderType.Ms2, MSOrderType.Ms3 }) { int[] scans = rawData.scanIndex.ScanEnumerators[MSOrder]; for (int i = 0; i < scans.Length; i++) { metaData[scans[i]].FillTime = rawData.trailerExtras[scans[i]].InjectionTime; // populate duty cycle if (i < scans.Length - 1) { metaData[scans[i]].DutyCycle = (rawData.retentionTimes[scans[i + 1]] - rawData.retentionTimes[scans[i]]) * 60; } else { metaData[scans[i]].DutyCycle = 0; } // populate scan rate if (MSOrder == MSOrderType.Ms2 | MSOrder == MSOrderType.Ms3) { metaData[scans[i]].MS2ScansPerCycle = metaData[rawData.precursorScans[scans[i]].MasterScan].MS2ScansPerCycle; } // populate intensity distributions if (rawData.methodData.MassAnalyzers[MSOrder] == MassAnalyzerType.MassAnalyzerFTMS) { metaData[scans[i]].IntensityDistribution = new Distribution(rawData.centroidStreams[scans[i]].Intensities); metaData[scans[i]].SummedIntensity = rawData.centroidStreams[scans[i]].Intensities.Sum(); } else { metaData[scans[i]].IntensityDistribution = new Distribution(rawData.segmentedScans[scans[i]].Intensities); metaData[scans[i]].SummedIntensity = rawData.segmentedScans[scans[i]].Intensities.Sum(); } // populate fraction of scans consuming 80% of total intensity if (rawData.methodData.MassAnalyzers[MSOrder] == MassAnalyzerType.MassAnalyzerFTMS) { metaData[scans[i]].FractionConsumingTop80PercentTotalIntensity = rawData.centroidStreams[scans[i]].Intensities.FractionOfScansConsumingTotalIntensity(percent: 80); } else { metaData[scans[i]].FractionConsumingTop80PercentTotalIntensity = rawData.segmentedScans[scans[i]].Intensities.FractionOfScansConsumingTotalIntensity(percent: 80); } // calculate ms1 isolation interference if (rawData.methodData.AnalysisOrder == MSOrder) { int preScan = rawData.precursorScans[scans[i]].MasterScan; metaData[scans[i]].Ms1IsolationInterference = Ms1Interference.CalculateForOneScan(rawData.centroidStreams[preScan], rawData.precursorMasses[scans[i]].MonoisotopicMZ, isoWindow, rawData.trailerExtras[scans[i]].ChargeState); } progress.Update(); } } progress.Done(); rawData.Performed.Add(Operations.MetaData); }
/// <summary> /// Write the RAW file metadata to file. /// <param name="rawFile">the RAW file object</param> /// <param name="firstScanNumber">the first scan number</param> /// <param name="lastScanNumber">the last scan number</param> /// </summary> public void WriteMetadata(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { // Get the start and end time from the RAW file var startTime = rawFile.RunHeaderEx.StartTime; var endTime = rawFile.RunHeaderEx.EndTime; // Collect the metadata var output = new List <string> { "#General information", "RAW file path=" + rawFile.FileName, "RAW file version=" + rawFile.FileHeader.Revision, "Creation date=" + rawFile.FileHeader.CreationDate, $"Created by=[MS, MS:1000529, created_by, {rawFile.FileHeader.WhoCreatedId}]", "Number of instruments=" + rawFile.InstrumentCount, "Description=" + rawFile.FileHeader.FileDescription, $"Instrument model=[MS, MS:1000494, Thermo Scientific instrument model, {rawFile.GetInstrumentData().Model}]", "Instrument name=" + rawFile.GetInstrumentData().Name, $"Instrument serial number=[MS, MS:1000529, instrument serial number, {rawFile.GetInstrumentData().SerialNumber}]", $"Software version=[NCIT, NCIT:C111093, Software Version, {rawFile.GetInstrumentData().SoftwareVersion}]", "Firmware version=" + rawFile.GetInstrumentData().HardwareVersion, "Units=" + rawFile.GetInstrumentData().Units, $"Mass resolution=[MS, MS:1000011, mass resolution, {rawFile.RunHeaderEx.MassResolution:F3}]", $"Number of scans={rawFile.RunHeaderEx.SpectraCount}", $"Scan range={firstScanNumber};{lastScanNumber}", $"Scan start time=[MS, MS:1000016, scan start time, {startTime:F2}]", $"Time range={startTime:F2};{endTime:F2}", $"Mass range={rawFile.RunHeaderEx.LowMass:F4};{rawFile.RunHeaderEx.HighMass:F4}", "", "#Sample information", "Sample name=" + rawFile.SampleInformation.SampleName, "Sample id=" + rawFile.SampleInformation.SampleId, "Sample type=" + rawFile.SampleInformation.SampleType, "Sample comment=" + rawFile.SampleInformation.Comment, "Sample vial=" + rawFile.SampleInformation.Vial, "Sample volume=" + rawFile.SampleInformation.SampleVolume, "Sample injection volume=" + rawFile.SampleInformation.InjectionVolume, "Sample row number=" + rawFile.SampleInformation.RowNumber, "Sample dilution factor=" + rawFile.SampleInformation.DilutionFactor }; // Write the meta data to file string metadataOutputPath; if (_outputDirectory == null) { metadataOutputPath = _metadataFileName; } else { metadataOutputPath = _outputDirectory + "/" + _metadataFileName + "-metadata.txt"; } File.WriteAllLines(metadataOutputPath, output.ToArray()); // Write the string array to a new file named "WriteLines.txt". //using (var outputFile = new StreamWriter(metadataOutputPath)) //{ // foreach (var line in output) // outputFile.WriteLine(line); //} }
/// <inheritdoc /> public override void Write(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { ConfigureWriter(".mgf"); using (Writer) { Log.Info("Processing " + (lastScanNumber - firstScanNumber + 1) + " scans"); var lastScanProgress = 0; for (var scanNumber = firstScanNumber; scanNumber <= lastScanNumber; scanNumber++) { if (ParseInput.LogFormat == LogFormat.DEFAULT) { var scanProgress = (int)((double)scanNumber / (lastScanNumber - firstScanNumber + 1) * 100); if (scanProgress % ProgressPercentageStep == 0) { if (scanProgress != lastScanProgress) { Console.Write("" + scanProgress + "% "); lastScanProgress = scanProgress; } } } // Get each scan from the RAW file var scan = Scan.FromFile(rawFile, scanNumber); // Check to see if the RAW file contains label (high-res) data and if it is present // then look for any data that is out of order var time = rawFile.RetentionTimeFromScanNumber(scanNumber); // Get the scan filter for this scan number var scanFilter = rawFile.GetFilterForScanNumber(scanNumber); // Get the scan event for this scan number var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); // precursor reference var spectrumRef = ""; //keeping track of precursor scan switch (scanFilter.MSOrder) { case MSOrderType.Ms: // Keep track of scan number for precursor reference _precursorMs1ScanNumber = scanNumber; break; case MSOrderType.Ms2: // Keep track of scan number and isolation m/z for precursor reference var result = Regex.Match(scanEvent.ToString(), FilterStringIsolationMzPattern); if (result.Success) { if (_precursorMs2ScanNumbers.ContainsKey(result.Groups[1].Value)) { _precursorMs2ScanNumbers.Remove(result.Groups[1].Value); } _precursorMs2ScanNumbers.Add(result.Groups[1].Value, scanNumber); } spectrumRef = ConstructSpectrumTitle((int)Device.MS, 1, _precursorMs1ScanNumber); break; case MSOrderType.Ms3: var precursorMs2ScanNumber = _precursorMs2ScanNumbers.Keys.FirstOrDefault( isolationMz => scanEvent.ToString().Contains(isolationMz)); if (!precursorMs2ScanNumber.IsNullOrEmpty()) { spectrumRef = ConstructSpectrumTitle((int)Device.MS, 1, _precursorMs2ScanNumbers[precursorMs2ScanNumber]); } else { throw new InvalidOperationException("Couldn't find a MS2 precursor scan for MS3 scan " + scanEvent); } break; default: break; } // don't include MS1 spectra if (ParseInput.MsLevel.Contains((int)scanFilter.MSOrder)) { IReaction reaction = GetReaction(scanEvent, scanNumber); Writer.WriteLine("BEGIN IONS"); if (ParseInput.MGFPrecursor) { Writer.WriteLine($"TITLE={ConstructSpectrumTitle((int)Device.MS, 1, scanNumber)} [PRECURSOR={spectrumRef}]"); } else { Writer.WriteLine($"TITLE={ConstructSpectrumTitle((int)Device.MS, 1, scanNumber)}"); } Writer.WriteLine($"SCANS={scanNumber}"); Writer.WriteLine( $"RTINSECONDS={(time * 60).ToString(CultureInfo.InvariantCulture)}"); // trailer extra data list var trailerData = rawFile.GetTrailerExtraInformation(scanNumber); int? charge = null; double?monoisotopicMz = null; double?isolationWidth = null; for (var i = 0; i < trailerData.Length; i++) { if (trailerData.Labels[i] == "Charge State:") { if (Convert.ToInt32(trailerData.Values[i]) > 0) { charge = Convert.ToInt32(trailerData.Values[i]); } } if (trailerData.Labels[i] == "Monoisotopic M/Z:") { monoisotopicMz = double.Parse(trailerData.Values[i], NumberStyles.Any, CultureInfo.CurrentCulture); } if (trailerData.Labels[i] == "MS" + (int)scanFilter.MSOrder + " Isolation Width:") { isolationWidth = double.Parse(trailerData.Values[i], NumberStyles.Any, CultureInfo.CurrentCulture); } } if (reaction != null) { var selectedIonMz = CalculateSelectedIonMz(reaction, monoisotopicMz, isolationWidth); Writer.WriteLine("PEPMASS=" + selectedIonMz.ToString(CultureInfo.InvariantCulture)); } // charge if (charge != null) { // Scan polarity var polarity = PositivePolarity; if (scanFilter.Polarity == PolarityType.Negative) { polarity = NegativePolarity; } Writer.WriteLine($"CHARGE={charge}{polarity}"); } // write the filter string //Writer.WriteLine($"SCANEVENT={scanEvent.ToString()}"); if (!ParseInput.NoPeakPicking) { // check if the scan has a centroid stream if (scan.HasCentroidStream) { if (scan.CentroidScan.Length > 0) { for (var i = 0; i < scan.CentroidScan.Length; i++) { Writer.WriteLine( scan.CentroidScan.Masses[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + scan.CentroidScan.Intensities[i].ToString("0.0000000000", CultureInfo.InvariantCulture)); } } } else // otherwise take segmented (low res) scan data { // if the spectrum is profile perform centroiding var segmentedScan = scanEvent.ScanData == ScanDataType.Profile ? Scan.ToCentroid(scan).SegmentedScan : scan.SegmentedScan; for (var i = 0; i < segmentedScan.Positions.Length; i++) { Writer.WriteLine( segmentedScan.Positions[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + segmentedScan.Intensities[i].ToString("0.0000000000", CultureInfo.InvariantCulture)); } } } else // use the segmented data as is { for (var i = 0; i < scan.SegmentedScan.Positions.Length; i++) { Writer.WriteLine( scan.SegmentedScan.Positions[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + scan.SegmentedScan.Intensities[i].ToString("0.0000000000", CultureInfo.InvariantCulture)); } } Writer.WriteLine("END IONS"); Log.Debug("Spectrum written to file -- SCAN " + scanNumber); } } if (ParseInput.LogFormat == LogFormat.DEFAULT) { Console.WriteLine(); } } }
/// <inheritdoc /> public abstract void Write(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber);
/// <summary> /// Dispose of the raw file object to handle memory situation /// </summary> /// <param name="rawFile"></param> private void CleanUpRawFile(IRawDataPlus rawFile) { rawFile.Dispose(); }
static int DoStuff(ArgumentParser.LogDumpOptions opts) { List <string> files = new List <string>(); if (opts.InputFiles.Count() > 0) // did the user give us a list of files? { List <string> problems = new List <string>(); files = opts.InputFiles.ToList(); // check if the list provided contains only .raw files foreach (string file in files) { if (!file.EndsWith(".raw", StringComparison.OrdinalIgnoreCase)) { problems.Add(file); } } if (problems.Count() == 1) { Console.WriteLine("\nERROR: {0} does not appear to be a .raw file. Invoke '>RawTools --help' if you need help.", problems.ElementAt(0)); Log.Error("Invalid file provided: {0}", problems.ElementAt(0)); return(1); } if (problems.Count() > 1) { Console.WriteLine("\nERROR: The following {0} files do not appear to be .raw files. Invoke '>RawTools --help' if you need help." + "\n\n{1}", problems.Count(), String.Join("\n", problems)); Log.Error("Invalid files provided: {0}", String.Join(" ", problems)); return(1); } Log.Information("Files to be processed, provided as list: {0}", String.Join(" ", files)); } else // did the user give us a directory? { if (Directory.Exists(opts.InputDirectory)) { files = Directory.GetFiles(opts.InputDirectory, "*.*", SearchOption.TopDirectoryOnly) .Where(s => s.EndsWith(".raw", StringComparison.OrdinalIgnoreCase)).ToList(); } else { Console.WriteLine("ERROR: The provided directory does not appear to be valid."); Log.Error("Invalid directory provided: {0}", opts.InputDirectory); return(1); } Log.Information("Files to be processed, provided as directory: {0}", String.Join(" ", files)); } Console.WriteLine(); foreach (var file in files) { Console.WriteLine(Path.GetFileName(file)); Console.WriteLine("----------------------------------------"); using (IRawDataPlus rawFile = RawFileReaderFactory.ReadFile(file)) { rawFile.SelectMsData(); var numberOfLogs = rawFile.GetStatusLogEntriesCount(); var logInfo = rawFile.GetStatusLogHeaderInformation(); string logName = file + ".INST_LOG.txt"; Dictionary <int, ISingleValueStatusLog> log = new Dictionary <int, ISingleValueStatusLog>(); ProgressIndicator P = new ProgressIndicator(logInfo.Count(), "Preparing log data"); P.Start(); for (int i = 0; i < logInfo.Count(); i++) { log.Add(i, rawFile.GetStatusLogAtPosition(i)); P.Update(); } P.Done(); using (StreamWriter f = new StreamWriter(logName)) { P = new ProgressIndicator(numberOfLogs, $"Writing log"); P.Start(); f.Write("Time\t"); foreach (var x in logInfo) { f.Write(x.Label + "\t"); } f.Write("\n"); for (int i = 0; i < numberOfLogs; i++) { f.Write($"{log[0].Times[i]}\t"); for (int j = 0; j < logInfo.Length; j++) { try { f.Write("{0}\t", log[j].Values[i]); } catch (Exception) { f.Write("\t"); } } f.Write("\n"); P.Update(); } P.Done(); } } Console.WriteLine("\n"); } return(0); }
public static void Check(this RawDataCollection rawData, IRawDataPlus rawFile, List <Operations> operations) { if (operations.Contains(Operations.MethodData)) { if (!rawData.Performed.Contains(Operations.MethodData)) { rawData.ExtractMethodData(rawFile); } } if (operations.Contains(Operations.PrecursorMasses)) { if (!rawData.Performed.Contains(Operations.PrecursorMasses)) { rawData.ExtractPrecursorMasses(rawFile); } } if (operations.Contains(Operations.PrecursorScans)) { if (!rawData.Performed.Contains(Operations.PrecursorScans)) { rawData.ExtractPrecursorScans(rawFile); } } if (operations.Contains(Operations.RetentionTimes)) { if (!rawData.Performed.Contains(Operations.RetentionTimes)) { rawData.ExtractRetentionTimes(rawFile); } } if (operations.Contains(Operations.ScanIndex)) { if (!rawData.Performed.Contains(Operations.ScanIndex)) { rawData.ExtractScanIndex(rawFile); } } if (operations.Contains(Operations.TrailerExtras)) { if (!rawData.Performed.Contains(Operations.TrailerExtras)) { rawData.ExtractTrailerExtra(rawFile); } } if (operations.Contains(Operations.Ms1CentroidStreams)) { if (!rawData.Performed.Contains(Operations.Ms1CentroidStreams)) { rawData.ExtractCentroidStreams(rawFile, MSOrder: MSOrderType.Ms); } } if (operations.Contains(Operations.Ms2CentroidStreams)) { if (!rawData.Performed.Contains(Operations.Ms2CentroidStreams)) { rawData.ExtractCentroidStreams(rawFile, MSOrder: MSOrderType.Ms2); } } if (operations.Contains(Operations.Ms3CentroidStreams)) { if (!rawData.Performed.Contains(Operations.Ms3CentroidStreams)) { rawData.ExtractCentroidStreams(rawFile, MSOrder: MSOrderType.Ms3); } } if (operations.Contains(Operations.Ms1SegmentedScans)) { if (!rawData.Performed.Contains(Operations.Ms1SegmentedScans)) { rawData.ExtractSegmentScans(rawFile, MSOrder: MSOrderType.Ms); } } if (operations.Contains(Operations.Ms2SegmentedScans)) { if (!rawData.Performed.Contains(Operations.Ms2SegmentedScans)) { rawData.ExtractSegmentScans(rawFile, MSOrder: MSOrderType.Ms2); } } if (operations.Contains(Operations.Ms3SegmentedScans)) { if (!rawData.Performed.Contains(Operations.Ms3SegmentedScans)) { rawData.ExtractSegmentScans(rawFile, MSOrder: MSOrderType.Ms3); } } if (operations.Contains(Operations.MetaData)) { if (!rawData.Performed.Contains(Operations.MetaData)) { rawData.metaData.AggregateMetaData(rawData, rawFile); } } if (operations.Contains(Operations.PeakRetAndInt)) { if (!rawData.Performed.Contains(Operations.PeakRetAndInt)) { AnalyzePeaks.CalcPeakRetTimesAndInts(rawData, rawFile); } } if (operations.Contains(Operations.PeakShape)) { if (!rawData.Performed.Contains(Operations.PeakShape)) { AnalyzePeaks.CalculatePeakShapes(rawData, rawFile); } } if (operations.Contains(Operations.PeakArea)) { if (!rawData.Performed.Contains(Operations.PeakArea)) { AnalyzePeaks.QuantifyPrecursorPeaks(rawData, rawFile); } } }
private static void WritePScans(string outputDirectory, string fileName, IRawDataPlus raw, List <PScan> scans) { var enumerator = raw.GetFilteredScanEnumerator(" "); foreach (var scanNumber in enumerator ) // note in my tests serial is faster than Parallel.Foreach() (this involves disk access, so it makes sense) { //trailer information is extracted via index var trailers = raw.GetTrailerExtraValues(scanNumber); var trailerLabels = raw.GetTrailerExtraInformation(scanNumber); object chargeState = 0; for (int i = 0; i < trailerLabels.Labels.Length; i++) { if (trailerLabels.Labels[i] == "Charge State:") { chargeState = raw.GetTrailerExtraValue(scanNumber, i); break; } } var scanFilter = raw.GetFilterForScanNumber(scanNumber); var scanStats = raw.GetScanStatsForScanNumber(scanNumber); CentroidStream centroidStream = new CentroidStream(); //check for FT mass analyzer data if (scanFilter.MassAnalyzer == MassAnalyzerType.MassAnalyzerFTMS) { centroidStream = raw.GetCentroidStream(scanNumber, false); } //check for IT mass analyzer data if (scanFilter.MassAnalyzer == MassAnalyzerType.MassAnalyzerITMS) { var scanData = raw.GetSimplifiedScan(scanNumber); centroidStream.Masses = scanData.Masses; centroidStream.Intensities = scanData.Intensities; } var msOrder = raw.GetScanEventForScanNumber(scanNumber).MSOrder; if (msOrder == MSOrderType.Ms) { var pscan = GetPScan(scanStats, centroidStream, fileName, Convert.ToInt32(chargeState)); scans.Add(pscan); } if (msOrder == MSOrderType.Ms2) { var precursorMz = raw.GetScanEventForScanNumber(scanNumber).GetReaction(0).PrecursorMass; var pscan = GetPScan(scanStats, centroidStream, fileName, precursorMz, Convert.ToInt32(chargeState)); scans.Add(pscan); } var t = raw.GetTrailerExtraValues(scanNumber); } WriteScans(outputDirectory, scans, fileName); }
public static TrailerExtraData ExtractTrailerExtra(RawDataCollection rawData, IRawDataPlus rawFile, int scan, TrailerExtraIndices indices) { TrailerExtraData trailerExtra = new TrailerExtraData(); Double[] spsMasses; if (indices.InjectionTime != -1) { trailerExtra.InjectionTime = Convert.ToDouble(rawFile.GetTrailerExtraValue(scan, indices.InjectionTime)); } if (indices.ChargeState != -1) { trailerExtra.ChargeState = Convert.ToInt32(rawFile.GetTrailerExtraValue(scan, indices.ChargeState)); } if (indices.MonoisotopicMZ != -1) { trailerExtra.MonoisotopicMZ = Convert.ToDouble(rawFile.GetTrailerExtraValue(scan, indices.MonoisotopicMZ)); } if (indices.MasterScan != -1) { try { trailerExtra.MasterScan = Convert.ToInt32(rawFile.GetTrailerExtraValue(scan, indices.MasterScan)); } // if that doesn't work the master scan is (hopefully) not applicable, we can leave it at the defaule value of -1 catch (FormatException) { } } if (indices.HCDEnergy != -1) { try { trailerExtra.HCDEnergy = Convert.ToDouble(rawFile.GetTrailerExtraValue(scan, indices.HCDEnergy)); } catch (FormatException) { } } if (indices.SPSMasses.Count > 2) // if so, this means with have all SPS masses listed individually { spsMasses = new double[indices.SPSMasses.Count]; for (int i = 0; i < indices.SPSMasses.Count; i++) { spsMasses[i] = Convert.ToDouble(rawFile.GetTrailerExtraValue(scan, indices.SPSMasses[i])); } } if (indices.SPSMasses.Count == 0) // there are no SPS masses { spsMasses = new double[0]; } else // they are broken into two lists of strings, comma delimited { char[] delimiter = { ' ', ',' }; string[] stringsps1 = rawFile.GetTrailerExtraValue(scan, indices.SPSMasses[0]).ToString().Split(delimiter, StringSplitOptions.RemoveEmptyEntries); string[] stringsps2 = rawFile.GetTrailerExtraValue(scan, indices.SPSMasses[1]).ToString().Split(delimiter, StringSplitOptions.RemoveEmptyEntries); double[] sps1 = Array.ConvertAll(stringsps1, Convert.ToDouble); double[] sps2 = Array.ConvertAll(stringsps2, Convert.ToDouble); spsMasses = new double[sps1.Length + sps2.Length]; sps1.CopyTo(spsMasses, 0); sps2.CopyTo(spsMasses, sps1.Length); } trailerExtra.SPSMasses = spsMasses; return(trailerExtra); }
/// <summary> /// Get the spectrum intensity. /// </summary> /// <param name="rawFile">the RAW file object</param> /// <param name="precursorScanNumber">the precursor scan number</param> /// <param name="precursorMass">the precursor mass</param> /// <param name="retentionTime">the retention time</param> /// <param name="isolationWidth">the isolation width</param> protected static double? GetPrecursorIntensity(IRawDataPlus rawFile, int precursorScanNumber, double precursorMass, double retentionTime, double? isolationWidth) { double? precursorIntensity = null; // Get the scan from the RAW file var scan = Scan.FromFile(rawFile, precursorScanNumber); // Check if the scan has a centroid stream if (scan.HasCentroidStream) { var centroidStream = rawFile.GetCentroidStream(precursorScanNumber, false); if (scan.CentroidScan.Length > 0) { for (var i = 0; i < centroidStream.Length; i++) { if (Math.Abs(precursorMass - centroidStream.Masses[i]) < Tolerance) { //Console.WriteLine(Math.Abs(precursorMass - centroidStream.Masses[i])); //Console.WriteLine(precursorMass + " - " + centroidStream.Masses[i] + " - " + // centroidStream.Intensities[i]); precursorIntensity = centroidStream.Intensities[i]; break; } } } } else { rawFile.SelectInstrument(Device.MS, 1); var component = new Component { MassRange = new Limit { Low = (double) (precursorMass - isolationWidth / 2), High = (double) (precursorMass + isolationWidth / 2) }, RtRange = new Limit { Low = rawFile.RetentionTimeFromScanNumber(precursorScanNumber), High = rawFile.RetentionTimeFromScanNumber(precursorScanNumber) } }; ; IChromatogramSettings[] allSettings = { new ChromatogramTraceSettings(TraceType.MassRange) { Filter = Component.Filter, MassRanges = new[] { new Range(component.MassRange.Low, component.MassRange.High) } } }; var rtFilteredScans = rawFile.GetFilteredScansListByTimeRange("", component.RtRange.Low, component.RtRange.High); var data = rawFile.GetChromatogramData(allSettings, rtFilteredScans[0], rtFilteredScans[rtFilteredScans.Count - 1]); var chromatogramTrace = ChromatogramSignal.FromChromatogramData(data); } return precursorIntensity; }
// Precursor scan number for reference in the precursor element of an MS2 spectrum public MgfSpectrumWriter(IRawDataPlus rawFile, ParseInput parseInput) : base(parseInput) { this._rawFile = rawFile; }
private static void ExtractIonChromatogramAsRcode(IRawDataPlus rawFile, int startScan, int endScan, List <double> massList, double ppmError, string filename, string filter = "ms") { if (IsValidFilter(rawFile, filter) == false) { using (System.IO.StreamWriter file = new System.IO.StreamWriter(filename)) { file.WriteLine("e$error <- \"'{0}' is not a valid filter string.\";", filter); } return; } List <ChromatogramTraceSettings> settingList = new List <ChromatogramTraceSettings>(); foreach (var mass in massList) { double massError = (0.5 * ppmError * mass) / 1000000; ChromatogramTraceSettings settings = new ChromatogramTraceSettings(TraceType.MassRange) { Filter = filter, MassRanges = new[] { ThermoFisher.CommonCore.Data.Business.Range.Create(mass - massError, mass + massError) } }; settingList.Add(settings); } IChromatogramSettings[] allSettings = settingList.ToArray(); var data = rawFile.GetChromatogramData(allSettings, startScan, endScan); // Split the data into the chromatograms var trace = ChromatogramSignal.FromChromatogramData(data); using (System.IO.StreamWriter file = new System.IO.StreamWriter(filename)) { file.WriteLine("#R\n"); for (int i = 0; i < trace.Length; i++) { List <double> tTime = new List <double>(); List <double> tIntensities = new List <double>(); for (int j = 0; j < trace[i].Times.Count; j++) { // if (trace[i].Intensities[j] > 0) { tTime.Add(trace[i].Times[j]); tIntensities.Add(trace[i].Intensities[j]); } } file.WriteLine("e$chromatogram[[{0}]] <- list(", i + 1); file.WriteLine("\tfilter = '{0}',", filter); file.WriteLine("\tppm = {0},", ppmError); file.WriteLine("\tmass = {0},", massList[i]); file.WriteLine("\ttimes = c(" + string.Join(",", tTime) + "),"); file.WriteLine("\tintensities = c(" + string.Join(",", tIntensities) + ")"); file.WriteLine(");"); } } }
/// <summary> /// </summary> /// <param name="rawFile"></param> /// <param name="filename"></param> /// <param name="L"></param> public static void WriteSpectrumAsRcode(this IRawDataPlus rawFile, string filename, List <int> L) { int count = 1; var trailerFields = rawFile.GetTrailerExtraHeaderInformation(); int indexCharge = rawFile.GetIndexOfPattern("Charge State"); int indexMonoisotopicmZ = rawFile.GetIndexOfPattern("MonoisotopicmZ"); using (System.IO.StreamWriter file = new System.IO.StreamWriter(filename)) { foreach (int scanNumber in L) { var basepeakMass = -1.0; var basepeakIntensity = -1.0; var scanStatistics = rawFile.GetScanStatsForScanNumber(scanNumber); var centroidStream = rawFile.GetCentroidStream(scanNumber, false); var scanTrailer = rawFile.GetTrailerExtraInformation(scanNumber); var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); var scan = Scan.FromFile(rawFile, scanNumber); file.WriteLine("e$Spectrum[[{0}]] <- list(", count++); file.WriteLine("\tscan = {0},", scanNumber); try { basepeakMass = (scanStatistics.BasePeakMass); basepeakIntensity = Math.Round(scanStatistics.BasePeakIntensity); file.WriteLine("\tbasePeak = c({0}, {1}),", basepeakMass, basepeakIntensity); } catch { file.WriteLine("\tbasePeak = c(NA, NA),"); } file.WriteLine("\tTIC = {0},", scanStatistics.TIC.ToString()); file.WriteLine("\tmassRange = c({0}, {1}),", scanStatistics.LowMass.ToString(), scanStatistics.HighMass.ToString()); file.WriteLine("\tscanType = \"{0}\",", scanStatistics.ScanType.ToString()); file.WriteLine("\trtinseconds = {0},", Math.Round(scanStatistics.StartTime * 60 * 1000) / 1000); try { var reaction0 = scanEvent.GetReaction(0); file.WriteLine("\tpepmass = {0},", reaction0.PrecursorMass); } catch { file.WriteLine("\tpepmass = NA,"); } if (scanStatistics.IsCentroidScan && centroidStream.Length > 0) { // Get the centroid (label) data from the RAW file for this scan file.WriteLine("\tcentroidStream = TRUE,"); file.WriteLine("\tHasCentroidStream = '{0}, Length={1}',", scan.HasCentroidStream, scan.CentroidScan.Length); if (scan.HasCentroidStream) { file.WriteLine("\tcentroid.mZ = c(" + string.Join(", ", scan.CentroidScan.Masses.ToArray()) + "),"); file.WriteLine("\tcentroid.intensity = c(" + string.Join(", ", scan.CentroidScan.Intensities.ToArray()) + "),"); } file.WriteLine("\ttitle = \"File: {0}; SpectrumID: {1}; scans: {2}\",", Path.GetFileName(rawFile.FileName), null, scanNumber); if (indexMonoisotopicmZ > 0) { file.WriteLine("\tmonoisotopicMz = {0},", Convert.ToDouble(scanTrailer.Values.ToArray()[indexMonoisotopicmZ])); } else { file.WriteLine("\tmonoisotopicMz = NA,"); } if (indexCharge > 0) { file.WriteLine("\tcharge = {0},", int.Parse(scanTrailer.Values.ToArray()[indexCharge])); } else { file.WriteLine("\tcharge = NA,"); } file.WriteLine("\tmZ = c(" + string.Join(", ", centroidStream.Masses) + "),"); file.WriteLine("\tintensity = c(" + string.Join(", ", centroidStream.Intensities) + "),"); file.WriteLine("\tnoises = c(" + string.Join(", ", centroidStream.Noises) + "),"); file.WriteLine("\tresolutions = c(" + string.Join(", ", centroidStream.Resolutions.ToArray()) + "),"); file.WriteLine("\tcharges = c(" + string.Join(", ", centroidStream.Charges) + "),"); file.WriteLine("\tbaselines = c(" + string.Join(", ", centroidStream.Baselines) + "),"); } else { file.WriteLine("\tcentroidStream = FALSE,"); file.WriteLine("\tHasCentroidStream = '{0}, Length={1}',", scan.HasCentroidStream, scan.CentroidScan.Length); if (scan.HasCentroidStream) { file.WriteLine("\tcentroid.mZ = c(" + string.Join(",", scan.CentroidScan.Masses.ToArray()) + "),"); file.WriteLine("\tcentroid.intensity = c(" + string.Join(",", scan.CentroidScan.Intensities.ToArray()) + "),"); } file.WriteLine("\ttitle = \"File: {0}; SpectrumID: {1}; scans: {2}\",", Path.GetFileName(rawFile.FileName), null, scanNumber); if (indexCharge > 0) { file.WriteLine("\tcharge = {0},", int.Parse(scanTrailer.Values.ToArray()[indexCharge])); } else { file.WriteLine("\tcharge = NA,"); } if (indexMonoisotopicmZ > 0) { file.WriteLine("\tmonoisotopicMz = {0},", Convert.ToDouble(scanTrailer.Values.ToArray()[indexMonoisotopicmZ])); } else { file.WriteLine("\tmonoisotopicMz = NA,"); } file.WriteLine("\tmZ = c(" + string.Join(",", scan.SegmentedScan.Positions) + "),"); file.WriteLine("\tintensity = c(" + string.Join(",", scan.SegmentedScan.Intensities) + "),"); // file.WriteLine("\tnoises = c(" + string.Join(",", scan.SegmentedScan.Noises) + "),"); } // ============= Instrument Data ============= // write scan Trailer var trailerValues = scanTrailer.Values; var trailerLabels = scanTrailer.Labels; var zipTrailer = trailerLabels.ToArray().Zip(trailerValues, (a, b) => string.Format("\t\"{0}\" = \"{1}\"", a, b)); file.WriteLine(string.Join(", \n", zipTrailer)); file.WriteLine(")"); } } return; }
public static void GetMetricsData(this MetricsData metricsData, ScanMetaDataCollection metaData, RawDataCollection rawData, IRawDataPlus rawFile, QuantDataCollection quantData = null) { List <Operations> operations = new List <Operations> { Operations.ScanIndex, Operations.RetentionTimes, Operations.MethodData, Operations.MetaData }; if (!rawData.isBoxCar) { operations.Add(Operations.PeakRetAndInt); operations.Add(Operations.PeakShape); } rawData.Check(rawFile, operations); metricsData.RawFileName = rawData.rawFileName; metricsData.Instrument = rawData.instrument; metricsData.MS1Analyzer = rawData.methodData.MassAnalyzers[MSOrderType.Ms]; metricsData.MS2Analyzer = rawData.methodData.MassAnalyzers[MSOrderType.Ms2]; metricsData.TotalAnalysisTime = rawData.retentionTimes[rawData.scanIndex.ScanEnumerators[MSOrderType.Any].Last()] - rawData.retentionTimes[rawData.scanIndex.ScanEnumerators[MSOrderType.Any].First()]; metricsData.TotalScans = rawData.scanIndex.allScans.Count(); metricsData.MS1Scans = rawData.scanIndex.ScanEnumerators[MSOrderType.Ms].Length; metricsData.MS2Scans = rawData.scanIndex.ScanEnumerators[MSOrderType.Ms2].Length; if (rawData.methodData.AnalysisOrder == MSOrderType.Ms3) { metricsData.MS3Analyzer = rawData.methodData.MassAnalyzers[MSOrderType.Ms3]; metricsData.MS3Scans = rawData.scanIndex.ScanEnumerators[MSOrderType.Ms3].Length; } else { metricsData.MS3Analyzer = MassAnalyzerType.Any; metricsData.MS3Scans = 0; } metricsData.MSOrder = rawData.methodData.AnalysisOrder; List <double> ms2intensities = new List <double>(); List <double> precursorIntensities = new List <double>(); List <double> ms1fillTimes = new List <double>(); List <double> ms2fillTimes = new List <double>(); List <double> ms3fillTimes = new List <double>(); List <double> ms2scansPerCycle = new List <double>(); List <double> dutyCycles = new List <double>(); List <double> fractionConsuming80 = new List <double>(); foreach (int scan in rawData.scanIndex.ScanEnumerators[MSOrderType.Ms]) { ms1fillTimes.Add(metaData[scan].FillTime); ms2scansPerCycle.Add(metaData[scan].MS2ScansPerCycle); dutyCycles.Add(metaData[scan].DutyCycle); } foreach (int scan in rawData.scanIndex.ScanEnumerators[MSOrderType.Ms2]) { precursorIntensities.Add(rawData.peakData[scan].ParentIntensity); ms2intensities.Add(metaData[scan].SummedIntensity); ms2fillTimes.Add(metaData[scan].FillTime); fractionConsuming80.Add(metaData[scan].FractionConsumingTop80PercentTotalIntensity); } if (rawData.methodData.AnalysisOrder == MSOrderType.Ms3) { foreach (int scan in rawData.scanIndex.ScanEnumerators[MSOrderType.Ms3]) { ms3fillTimes.Add(metaData[scan].FillTime); } } metricsData.MedianPrecursorIntensity = precursorIntensities.ToArray().Percentile(50); metricsData.MedianMs2FractionConsumingTop80PercentTotalIntensity = fractionConsuming80.ToArray().Percentile(50); metricsData.MedianSummedMS2Intensity = ms2intensities.ToArray().Percentile(50); metricsData.MedianMS1FillTime = ms1fillTimes.ToArray().Percentile(50); metricsData.MedianMS2FillTime = ms2fillTimes.ToArray().Percentile(50); if (rawData.methodData.AnalysisOrder == MSOrderType.Ms3) { metricsData.MedianMS3FillTime = ms3fillTimes.ToArray().Percentile(50); } else { metricsData.MedianMS3FillTime = -1; } metricsData.MeanTopN = ms2scansPerCycle.Average(); metricsData.MeanDutyCycle = dutyCycles.Average(); metricsData.MS1ScanRate = metricsData.MS1Scans / metricsData.TotalAnalysisTime; metricsData.MS2ScanRate = metricsData.MS2Scans / metricsData.TotalAnalysisTime; metricsData.MS3ScanRate = metricsData.MS3Scans / metricsData.TotalAnalysisTime; // only do the following if it isn't a boxcar experiment if (!rawData.isBoxCar) { metricsData.MedianBaselinePeakWidth = rawData.peakData.PeakShapeMedians.Width.P10; metricsData.MedianHalfHeightPeakWidth = rawData.peakData.PeakShapeMedians.Width.P50; // we can't access the instrument method in Linux, so we will assume the gradient length is the length of the MS acquisition metricsData.Gradient = rawData.retentionTimes[rawData.scanIndex.allScans.Keys.Max()]; metricsData.PeakCapacity = metricsData.Gradient / metricsData.MedianHalfHeightPeakWidth; metricsData.MedianAsymmetryFactor = rawData.peakData.PeakShapeMedians.Asymmetry.P10; } // add isolation interference metricsData.MedianMs1IsolationInterference = (from scan in rawData.scanIndex.ScanEnumerators[rawData.methodData.AnalysisOrder] select rawData.metaData[scan].Ms1IsolationInterference).ToArray().Percentile(50); // now add the quant meta data, if quant was performed double medianReporterIntensity = 0; QuantMetaData quantMetaData = new QuantMetaData(); SerializableDictionary <string, double> medianReporterIntensityByChannel = new SerializableDictionary <string, double>(); if (quantData != null & rawData.Performed.Contains(Operations.Quantification)) { string reagent = quantData.LabelingReagents; string[] allTags = new LabelingReagents().Reagents[reagent].Labels; List <double> allChannels = new List <double>(); Dictionary <string, List <double> > byChannel = new Dictionary <string, List <double> >(); foreach (string tag in allTags) { byChannel.Add(tag, new List <double>()); } foreach (int scan in rawData.scanIndex.ScanEnumerators[rawData.methodData.AnalysisOrder]) { foreach (string tag in allTags) { byChannel[tag].Add(quantData[scan][tag].Intensity); allChannels.Add(quantData[scan][tag].Intensity); } } medianReporterIntensity = allChannels.ToArray().Percentile(50); foreach (string tag in allTags) { medianReporterIntensityByChannel[tag] = byChannel[tag].ToArray().Percentile(50); } quantMetaData.medianReporterIntensity = medianReporterIntensity; quantMetaData.medianReporterIntensityByChannel = medianReporterIntensityByChannel; quantMetaData.quantTags = allTags; metricsData.QuantMeta = quantMetaData; metricsData.IncludesQuant = true; } }
private static MzSpectrum GetSpectrum(IRawDataPlus rawFile, IFilteringParams filterParams, int scanNumber, string scanFilter, int scanOrder) { MzSpectrum spectrum; double[] xArray; double[] yArray; if (string.IsNullOrEmpty(scanFilter)) { return(new MzSpectrum(new double[0], new double[0], false)); } var centroidStream = rawFile.GetCentroidStream(scanNumber, false); // PreferredMasses should be used if centroidStream data is null; it's probably ITMS data if (centroidStream.Masses == null || centroidStream.Intensities == null) { var scan = Scan.FromFile(rawFile, scanNumber); var mzs = scan.PreferredMasses; xArray = scan.PreferredMasses; yArray = scan.PreferredIntensities; if (xArray == null || yArray == null) { throw new MzLibException("Could not centroid data from scan " + scanNumber); } } else { xArray = centroidStream.Masses; yArray = centroidStream.Intensities; } if (filterParams != null && xArray.Length > 0 && (filterParams.MinimumAllowedIntensityRatioToBasePeakM.HasValue || filterParams.NumberOfPeaksToKeepPerWindow.HasValue) && ((filterParams.ApplyTrimmingToMs1 && scanOrder == 1) || (filterParams.ApplyTrimmingToMsMs && scanOrder > 1))) { var count = xArray.Length; var mzArray = new double[count]; var intensityArray = new double[count]; Array.Copy(xArray, mzArray, count); Array.Copy(yArray, intensityArray, count); var scanStats = rawFile.GetScanStatsForScanNumber(scanNumber); double scanRangeHigh = scanStats.HighMass; double scanRangeLow = scanStats.LowMass; WindowModeHelper(ref intensityArray, ref mzArray, filterParams, scanRangeLow, scanRangeHigh); Array.Sort(mzArray, intensityArray); spectrum = new MzSpectrum(mzArray, intensityArray, false); } else { spectrum = new MzSpectrum(xArray, yArray, false); } return(spectrum); }
public static void ExtractScanIndex(this RawDataCollection rawData, IRawDataPlus rawFile) { Log.Information("Extracting scan indices"); Dictionary <int, (MSOrderType MSOrder, MassAnalyzerType MassAnalyzer)> allScans; allScans = new Dictionary <int, (MSOrderType MSOrder, MassAnalyzerType MassAnalyzer)>(); MSOrderType AnalysisOrder; List <int> ms1 = new List <int>(); List <int> ms2 = new List <int>(); List <int> ms3 = new List <int>(); List <int> msAny = new List <int>(); // populate the scan indices IEnumerable <int> scans = rawFile.GetFilteredScanEnumerator(rawFile.GetFilterFromString("")); // get all scans foreach (int scan in scans) { IScanEvent scanEvent = rawFile.GetScanEventForScanNumber(scan); allScans.Add(scan, (scanEvent.MSOrder, scanEvent.MassAnalyzer)); msAny.Add(scan); if (allScans[scan].MSOrder == MSOrderType.Ms) { ms1.Add(scan); } if (allScans[scan].MSOrder == MSOrderType.Ms2) { ms2.Add(scan); } if (allScans[scan].MSOrder == MSOrderType.Ms3) { ms3.Add(scan); } } // determine the msorder of the experiment if ((ms1.Count > 0) & (ms2.Count == 0) & (ms3.Count == 0)) { AnalysisOrder = MSOrderType.Ms; } else { if ((ms1.Count > 0) & (ms2.Count > 0) & (ms3.Count == 0)) { AnalysisOrder = MSOrderType.Ms2; } else { AnalysisOrder = MSOrderType.Ms3; } } rawData.scanIndex = new ScanIndex(); rawData.scanIndex.allScans = allScans; rawData.scanIndex.AnalysisOrder = AnalysisOrder; rawData.scanIndex.ScanEnumerators.Add(MSOrderType.Any, msAny.ToArray()); rawData.scanIndex.ScanEnumerators.Add(MSOrderType.Ms, ms1.ToArray()); rawData.scanIndex.ScanEnumerators.Add(MSOrderType.Ms2, ms2.ToArray()); rawData.scanIndex.ScanEnumerators.Add(MSOrderType.Ms3, ms3.ToArray()); // we need to check if it is a boxcar file because those have some scan index issues bool isBoxCar = rawFile.GetScanEventForScanNumber(1).MassRangeCount > 1; rawData.Performed.Add(Operations.ScanIndex); if (isBoxCar) { Log.Information("Raw file looks like a boxcar run. Scan indices being adjusted to account for missing scan dependents."); rawData.ExtractPrecursorScans(rawFile); rawData.scanIndex.ScanEnumerators[rawData.scanIndex.AnalysisOrder] = rawData.precursorScans.Keys.ToArray(); } }
/// <summary> /// Loads all scan data from a Thermo .raw file. /// </summary> public static ThermoRawFileReaderData LoadAllStaticData(string filePath, IFilteringParams filterParams = null, int maxThreads = -1) { if (!File.Exists(filePath)) { throw new FileNotFoundException(); } Loaders.LoadElements(); // I don't know why this line needs to be here, but it does... var temp = RawFileReaderAdapter.FileFactory(filePath); var threadManager = RawFileReaderFactory.CreateThreadManager(filePath); var rawFileAccessor = threadManager.CreateThreadAccessor(); if (!rawFileAccessor.IsOpen) { throw new MzLibException("Unable to access RAW file!"); } if (rawFileAccessor.IsError) { throw new MzLibException("Error opening RAW file!"); } if (rawFileAccessor.InAcquisition) { throw new MzLibException("RAW file still being acquired!"); } rawFileAccessor.SelectInstrument(Device.MS, 1); var msDataScans = new MsDataScan[rawFileAccessor.RunHeaderEx.LastSpectrum]; Parallel.ForEach(Partitioner.Create(0, msDataScans.Length), new ParallelOptions { MaxDegreeOfParallelism = maxThreads }, (fff, loopState) => { IRawDataPlus myThreadDataReader = threadManager.CreateThreadAccessor(); myThreadDataReader.SelectInstrument(Device.MS, 1); for (int s = fff.Item1; s < fff.Item2; s++) { try { var scan = GetOneBasedScan(myThreadDataReader, filterParams, s + 1); msDataScans[s] = scan; } catch (Exception ex) { throw new MzLibException("Error reading scan " + (s + 1) + ": " + ex.Message); } } }); rawFileAccessor.Dispose(); string sendCheckSum; using (FileStream stream = File.OpenRead(filePath)) { using (SHA1Managed sha = new SHA1Managed()) { byte[] checksum = sha.ComputeHash(stream); sendCheckSum = BitConverter.ToString(checksum) .Replace("-", string.Empty); } } SourceFile sourceFile = new SourceFile( @"Thermo nativeID format", @"Thermo RAW format", sendCheckSum, @"SHA-1", filePath, Path.GetFileNameWithoutExtension(filePath)); return(new ThermoRawFileReaderData(msDataScans, sourceFile)); }
public static void ExtractAll(this RawDataCollection rawData, IRawDataPlus rawFile) { Log.Information("Beginning extraction of all possible data"); rawFile.SelectInstrument(Device.MS, 1); rawData.ExtractPrecursorScans(rawFile); ProgressIndicator P = new ProgressIndicator(rawData.scanIndex.allScans.Count(), "Extracting raw data"); TrailerExtraIndices indices = new TrailerExtraIndices(rawFile); for (int i = 1; i <= rawData.scanIndex.allScans.Count(); i++) { try { // first get out the mass spectrum if (rawData.scanIndex.allScans[i].MassAnalyzer == MassAnalyzerType.MassAnalyzerFTMS) { rawData.centroidStreams.Add(i, new CentroidStreamData(rawFile.GetCentroidStream(i, false))); } else { rawData.segmentedScans.Add(i, new SegmentedScanData(rawFile.GetSegmentedScanFromScanNumber(i, null))); } // add the trailer extra data rawData.trailerExtras.Add(i, TrailerExtras.ExtractTrailerExtra(rawData, rawFile, i, indices)); rawData.Performed.Add(Operations.TrailerExtras); // add the retention time rawData.retentionTimes.Add(i, rawFile.RetentionTimeFromScanNumber(i)); rawData.Performed.Add(Operations.RetentionTimes); // add the precursor mass PrecursorMasses.ExtractPrecursorMasses(rawData, rawFile, i); rawData.Performed.Add(Operations.PrecursorMasses); P.Update(); } catch (Exception e) { Log.Error("Extraction failed on scan {Scan}", i); throw e; } } if (rawData.methodData.AnalysisOrder == MSOrderType.Ms2 | rawData.methodData.AnalysisOrder == MSOrderType.Ms3) { rawData.Performed.Add(Operations.Ms1CentroidStreams); if (rawData.methodData.MassAnalyzers[MSOrderType.Ms2] == MassAnalyzerType.MassAnalyzerFTMS) { rawData.Performed.Add(Operations.Ms2CentroidStreams); } else { rawData.Performed.Add(Operations.Ms2SegmentedScans); } } if (rawData.methodData.AnalysisOrder == MSOrderType.Ms3) { if (rawData.methodData.MassAnalyzers[MSOrderType.Ms3] == MassAnalyzerType.MassAnalyzerFTMS) { rawData.Performed.Add(Operations.Ms3CentroidStreams); } else { rawData.Performed.Add(Operations.Ms3SegmentedScans); } } P.Done(); }
/// <inheritdoc /> public override void Write(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { ConfigureWriter(".mgf"); using (Writer) { for (var scanNumber = firstScanNumber; scanNumber <= lastScanNumber; scanNumber++) { // Get each scan from the RAW file var scan = Scan.FromFile(rawFile, scanNumber); // Check to see if the RAW file contains label (high-res) data and if it is present // then look for any data that is out of order var time = rawFile.RetentionTimeFromScanNumber(scanNumber); // Get the scan filter for this scan number var scanFilter = rawFile.GetFilterForScanNumber(scanNumber); // Get the scan event for this scan number var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); switch (scanFilter.MSOrder) { case MSOrderType.Ms: // Keep track of scan number for precursor reference _precursorScanNumber = scanNumber; break; case MSOrderType.Ms2: { if (scanEvent.ScanData == ScanDataType.Centroid || (scanEvent.ScanData == ScanDataType.Profile && (scan.HasCentroidStream || ParseInput.OutputFormat != OutputFormat.MGFNoProfileData))) { Writer.WriteLine("BEGIN IONS"); Writer.WriteLine($"TITLE={ConstructSpectrumTitle(scanNumber)}"); Writer.WriteLine($"SCANS={scanNumber}"); Writer.WriteLine($"RTINSECONDS={(time * 60).ToString(CultureInfo.InvariantCulture)}"); // Get the reaction information for the first precursor try { var reaction = scanEvent.GetReaction(0); var precursorMass = reaction.PrecursorMass; Writer.WriteLine("PEPMASS=" + precursorMass.ToString("0.0000000", CultureInfo.InvariantCulture)); //var precursorIntensity = 0.0; //GetPrecursorIntensity(rawFile, _precursorScanNumber, precursorMass); //Writer.WriteLine(precursorIntensity != null // ? $"PEPMASS={precursorMass:F7} {precursorIntensity}" // : $"PEPMASS={precursorMass:F7}"); } catch (ArgumentOutOfRangeException exception) { Log.Warn("No reaction found for scan " + scanNumber); } // trailer extra data list var trailerData = rawFile.GetTrailerExtraInformation(scanNumber); for (var i = 0; i < trailerData.Length; i++) { if (trailerData.Labels[i] == "Charge State:") { if (Convert.ToInt32(trailerData.Values[i]) > 0) { Writer.WriteLine($"CHARGE={trailerData.Values[i]}+"); } } } // write the filter string //Writer.WriteLine($"SCANEVENT={scanEvent.ToString()}"); // Check if the scan has a centroid stream if (scan.HasCentroidStream) { var centroidStream = rawFile.GetCentroidStream(scanNumber, false); if (scan.CentroidScan.Length > 0) { for (var i = 0; i < centroidStream.Length; i++) { Writer.WriteLine( centroidStream.Masses[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + centroidStream.Intensities[i].ToString("0.0000000", CultureInfo.InvariantCulture)); } } } // Otherwise take the profile data else { // Get the scan statistics from the RAW file for this scan number var scanStatistics = rawFile.GetScanStatsForScanNumber(scanNumber); // Get the segmented (low res and profile) scan data var segmentedScan = rawFile.GetSegmentedScanFromScanNumber(scanNumber, scanStatistics); for (var i = 0; i < segmentedScan.Positions.Length; i++) { Writer.WriteLine( segmentedScan.Positions[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + segmentedScan.Intensities[i].ToString("0.0000000000", CultureInfo.InvariantCulture)); } } Writer.WriteLine("END IONS"); } break; } } } } }
public static void ParseSearchResults(this QcDataContainer qcData, RawDataCollection rawData, IRawDataPlus rawFile, QcParameters qcParameters) { XElement results = LoadSearchResults(qcParameters, rawData); PsmDataCollection Psms = ExtractPsmData(results, qcParameters.searchParameters.SearchAlgorithm); qcData.ParsePSMs(Psms, qcParameters); }
/// <summary> /// Write the RAW file metadata to file. /// <param name="rawFile">the RAW file object</param> /// <param name="firstScanNumber">the first scan number</param> /// <param name="lastScanNumber">the last scan number</param> /// </summary> public void WriteJsonMetada(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { // Get the start and end time from the RAW file var startTime = rawFile.RunHeaderEx.StartTime; var endTime = rawFile.RunHeaderEx.EndTime; var metadata = new Metadata(); /** File Properties **/ metadata.addFileProperty("path", rawFile.FileName); metadata.addFileProperty("version", rawFile.FileHeader.Revision.ToString()); metadata.addFileProperty("creation-date", rawFile.FileHeader.CreationDate.ToString()); metadata.addFileProperty("number-instruments", rawFile.InstrumentCount.ToString()); metadata.addFileProperty("description", rawFile.FileHeader.FileDescription); /** Sample Properties **/ metadata.addSampleProperty("name", rawFile.SampleInformation.SampleName); metadata.addSampleProperty("id", rawFile.SampleInformation.SampleId); metadata.addSampleProperty("type", rawFile.SampleInformation.SampleType.ToString()); metadata.addSampleProperty("comment", rawFile.SampleInformation.Comment); metadata.addSampleProperty("vial", rawFile.SampleInformation.Vial); metadata.addSampleProperty("volume", rawFile.SampleInformation.SampleVolume.ToString()); metadata.addSampleProperty("injection-volume", rawFile.SampleInformation.InjectionVolume.ToString()); metadata.addSampleProperty("row-number", rawFile.SampleInformation.RowNumber.ToString()); metadata.addSampleProperty("dilution-factor", rawFile.SampleInformation.DilutionFactor.ToString()); metadata.addScanSetting("start-time", new CVTerm("MS:1000016", "MS", "scan start time", startTime.ToString())); metadata.addScanSetting("resolution", new CVTerm("MS:1000011", "MS", "mass resolution", rawFile.RunHeaderEx.MassResolution.ToString())); metadata.addScanSetting("tolerance-unit", new CVTerm("UO:0000002", "MS", "mass unit", rawFile.GetInstrumentData().Units.ToString())); metadata.addScanSetting("number-scans", rawFile.RunHeaderEx.SpectraCount.ToString()); metadata.addScanSetting("scan-range", firstScanNumber + ":" + lastScanNumber); metadata.addScanSetting("time-range", startTime + ":" + endTime); metadata.addScanSetting("mass-range", rawFile.RunHeaderEx.LowMass + ":" + rawFile.RunHeaderEx.HighMass); metadata.addInstrumentProperty("model", new CVTerm("MS:1000494", "MS", "Thermo Scientific instrument model", rawFile.GetInstrumentData().Model)); metadata.addInstrumentProperty("name", new CVTerm("MS:1000496", "MS", "instrument attribute", rawFile.GetInstrumentData().Name)); metadata.addInstrumentProperty("serial", new CVTerm("MS:1000529", "MS", "instrument serial number", rawFile.GetInstrumentData().SerialNumber)); var msTypes = new Dictionary <string, int>(); double minTime = 1000000000000000; double maxTime = 0; double minMz = 1000000000000000000; double maxMz = 0; double minCharge = 100000000000000; double maxCharge = 0; HashSet <CVTerm> fragmentationType = new HashSet <CVTerm>(CVTerm.CvTermComparer); for (var scanNumber = firstScanNumber; scanNumber <= lastScanNumber; scanNumber++) { var time = rawFile.RetentionTimeFromScanNumber(scanNumber); // Get the scan filter for this scan number var scanFilter = rawFile.GetFilterForScanNumber(scanNumber); // Get the scan event for this scan number var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); // Only consider MS2 spectra if (msTypes.ContainsKey(scanFilter.MSOrder.ToString())) { var value = msTypes[scanFilter.MSOrder.ToString()]; value = value + 1; msTypes[scanFilter.MSOrder.ToString()] = value; } else { msTypes.Add(scanFilter.MSOrder.ToString(), 1); } if (time > maxTime) { maxTime = time; } if (time < minTime) { minTime = time; } if (scanFilter.MSOrder == MSOrderType.Ms2) { fragmentationType.Add(parseActivationType(scanFilter.GetActivation(0))); if (scanEvent.ScanData == ScanDataType.Centroid || (scanEvent.ScanData == ScanDataType.Profile)) { try { var reaction = scanEvent.GetReaction(0); var precursorMass = reaction.PrecursorMass; if (precursorMass > maxMz) { maxMz = precursorMass; } if (precursorMass < minMz) { minMz = precursorMass; } } catch (ArgumentOutOfRangeException exception) { Log.Warn("No reaction found for scan " + scanNumber); } // trailer extra data list var trailerData = rawFile.GetTrailerExtraInformation(scanNumber); for (var i = 0; i < trailerData.Length; i++) { if (trailerData.Labels[i] == "Charge State:") { if (Int32.Parse(trailerData.Values[i]) > maxCharge) { maxCharge = Int32.Parse(trailerData.Values[i]); } if (Int32.Parse(trailerData.Values[i]) < minCharge) { maxCharge = Int32.Parse(trailerData.Values[i]); } } } } } } if (minCharge == 100000000000000) { minCharge = 0; } metadata.addMSData("ms-number", msTypes); metadata.addMSData("activation-ypes", fragmentationType); metadata.addMSData("min-charge", minCharge); metadata.addMSData("max-charge", maxCharge); metadata.addMSData("min-Time", minTime); metadata.addMSData("max-Time", maxTime); metadata.addMSData("min-Mz", minMz); metadata.addMSData("max-Mz", maxMz); // Write the meta data to file var json = JsonConvert.SerializeObject(metadata); json.Replace("\r\n", "\n"); File.WriteAllText(_outputDirectory + "/" + _rawFileNameWithoutExtension + "-metadata.json", json); }
public static void WriteToDisk(WorkFlows.WorkflowParameters opts) { List <string> files = new List <string>(); Console.WriteLine(); Console.WriteLine("Writing log files"); foreach (var file in files) { Console.WriteLine(Path.GetFileName(file)); Console.WriteLine("----------------------------------------"); using (IRawDataPlus rawFile = RawFileReaderFactory.ReadFile(file)) { rawFile.SelectMsData(); var numberOfLogs = rawFile.GetStatusLogEntriesCount(); var logInfo = rawFile.GetStatusLogHeaderInformation(); string logName = file + ".INST_LOG.txt"; Dictionary <int, ISingleValueStatusLog> log = new Dictionary <int, ISingleValueStatusLog>(); ProgressIndicator P = new ProgressIndicator(logInfo.Count(), "Preparing log data"); P.Start(); for (int i = 0; i < logInfo.Count(); i++) { log.Add(i, rawFile.GetStatusLogAtPosition(i)); P.Update(); } P.Done(); using (StreamWriter f = new StreamWriter(logName)) { P = new ProgressIndicator(numberOfLogs, $"Writing log"); P.Start(); f.Write("Time\t"); foreach (var x in logInfo) { f.Write(x.Label + "\t"); } f.Write("\n"); for (int i = 0; i < numberOfLogs; i++) { f.Write($"{log[0].Times[i]}\t"); for (int j = 0; j < logInfo.Length; j++) { try { f.Write("{0}\t", log[j].Values[i]); } catch (Exception) { f.Write("\t"); } } f.Write("\n"); P.Update(); } P.Done(); } } Console.WriteLine("\n"); } }
/// <inheritdoc /> public override void Write(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { ConfigureWriter(".mgf"); using (Writer) { for (var scanNumber = firstScanNumber; scanNumber <= lastScanNumber; scanNumber++) { // Get each scan from the RAW file var scan = Scan.FromFile(rawFile, scanNumber); // Check to see if the RAW file contains label (high-res) data and if it is present // then look for any data that is out of order var time = rawFile.RetentionTimeFromScanNumber(scanNumber); // Get the scan filter for this scan number var scanFilter = rawFile.GetFilterForScanNumber(scanNumber); // Get the scan event for this scan number var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); // Only consider MS2 spectra if (scanFilter.MSOrder == MSOrderType.Ms2) { if (scanEvent.ScanData == ScanDataType.Centroid || (scanEvent.ScanData == ScanDataType.Profile && !ParseInput.ExcludeProfileData)) { Writer.WriteLine("BEGIN IONS"); Writer.WriteLine($"TITLE={ConstructSpectrumTitle(scanNumber)}"); Writer.WriteLine($"SCAN={scanNumber}"); Writer.WriteLine($"RTINSECONDS={time * 60}"); // Get the reaction information for the first precursor try { var reaction = scanEvent.GetReaction(0); var precursorMass = reaction.PrecursorMass; Writer.WriteLine($"PEPMASS={precursorMass:F7}"); } catch (ArgumentOutOfRangeException exception) { Log.Warn("No reaction found for scan " + scanNumber); } // trailer extra data list var trailerData = rawFile.GetTrailerExtraInformation(scanNumber); for (var i = 0; i < trailerData.Length; i++) { if (trailerData.Labels[i] == "Charge State:") { if (Convert.ToInt32(trailerData.Values[i]) > 0) { Writer.WriteLine($"CHARGE={trailerData.Values[i]}+"); } } } // Check if the scan has a centroid stream if (scan.HasCentroidStream) { var centroidStream = rawFile.GetCentroidStream(scanNumber, false); if (scan.CentroidScan.Length > 0) { for (var i = 0; i < centroidStream.Length; i++) { Writer.WriteLine( $"{centroidStream.Masses[i]:F7} {centroidStream.Intensities[i]:F10}"); } } } // Otherwise take the profile data else { // Get the scan statistics from the RAW file for this scan number var scanStatistics = rawFile.GetScanStatsForScanNumber(scanNumber); // Get the segmented (low res and profile) scan data var segmentedScan = rawFile.GetSegmentedScanFromScanNumber(scanNumber, scanStatistics); for (var i = 0; i < segmentedScan.Positions.Length; i++) { Writer.WriteLine( $"{segmentedScan.Positions[i]:F7} {segmentedScan.Intensities[i]:F10}"); } } Writer.WriteLine("END IONS"); } } } } }
public static void WriteSearchMGF(QcParameters qcParameters, RawDataCollection rawData, IRawDataPlus rawFile, bool fixedScans = false) { var pars = qcParameters.searchParameters; int[] scans = AdditionalMath.SelectRandomScans(scans: rawData.scanIndex.ScanEnumerators[MSOrderType.Ms2], num: pars.NumSpectra, fixedScans: fixedScans); MGF.WriteMGF(rawData, rawFile, qcParameters.QcSearchDataDirectory, pars.MgfMassCutoff, scans, pars.MgfIntensityCutoff); }
/// <summary> /// Write the RAW file metadata to file. /// <param name="rawFile">the RAW file object</param> /// <param name="firstScanNumber">the first scan number</param> /// <param name="lastScanNumber">the last scan number</param> /// </summary> public void WriteJsonMetada(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { // Get the start and end time from the RAW file var startTime = rawFile.RunHeaderEx.StartTime; var endTime = rawFile.RunHeaderEx.EndTime; var metadata = new Metadata(); // File Properties metadata.addFileProperty(new CVTerm("NCIT:C47922", "NCIT", "Pathname", rawFile.FileName)); metadata.addFileProperty(new CVTerm("NCIT:C25714", "NCIT", "Version", rawFile.FileHeader.Revision.ToString())); metadata.addFileProperty(new CVTerm("NCIT:C69199", "NCIT", "Content Creation Date", rawFile.FileHeader.CreationDate.ToString())); metadata.addFileProperty(new CVTerm("NCIT:C25365", "NCIT", "Description", rawFile.FileHeader.FileDescription)); metadata.addScanSetting(new CVTerm("MS:1000016", "MS", "scan start time", startTime.ToString())); metadata.addScanSetting(new CVTerm("MS:1000011", "MS", "mass resolution", rawFile.RunHeaderEx.MassResolution.ToString())); metadata.addScanSetting(new CVTerm("UO:0000002", "MS", "mass unit", rawFile.GetInstrumentData().Units.ToString())); metadata.addScanSetting(new CVTerm("PRIDE:0000478", "PRIDE", "Number of scans", rawFile.RunHeaderEx.SpectraCount.ToString())); metadata.addScanSetting(new CVTerm("PRIDE:0000479", "PRIDE", "MS scan range", firstScanNumber + ":" + lastScanNumber)); metadata.addScanSetting(new CVTerm("PRIDE:0000484", "PRIDE", "Retention time range", startTime + ":" + endTime)); metadata.addScanSetting(new CVTerm("PRIDE:0000485", "PRIDE", "Mz range", rawFile.RunHeaderEx.LowMass + ":" + rawFile.RunHeaderEx.HighMass)); metadata.addInstrumentProperty(new CVTerm("MS:1000494", "MS", "Thermo Scientific instrument model", rawFile.GetInstrumentData().Model)); metadata.addInstrumentProperty(new CVTerm("MS:1000496", "MS", "instrument attribute", rawFile.GetInstrumentData().Name)); metadata.addInstrumentProperty(new CVTerm("MS:1000529", "MS", "instrument serial number", rawFile.GetInstrumentData().SerialNumber)); var msTypes = new Dictionary <string, int>(); double minTime = 1000000000000000; double maxTime = 0; double minMz = 1000000000000000000; double maxMz = 0; double minCharge = 100000000000000; double maxCharge = 0; ICollection <CVTerm> fragmentationType = new HashSet <CVTerm>(CVTerm.CvTermComparer); for (var scanNumber = firstScanNumber; scanNumber <= lastScanNumber; scanNumber++) { var time = rawFile.RetentionTimeFromScanNumber(scanNumber); // Get the scan filter for this scan number var scanFilter = rawFile.GetFilterForScanNumber(scanNumber); // Get the scan event for this scan number var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); // Only consider MS2 spectra if (msTypes.ContainsKey(scanFilter.MSOrder.ToString())) { var value = msTypes[scanFilter.MSOrder.ToString()]; value = value + 1; msTypes[scanFilter.MSOrder.ToString()] = value; } else { msTypes.Add(scanFilter.MSOrder.ToString(), 1); } if (time > maxTime) { maxTime = time; } if (time < minTime) { minTime = time; } if (scanFilter.MSOrder == MSOrderType.Ms2) { fragmentationType.Add(ParseActivationType(scanFilter.GetActivation(0))); if (scanEvent.ScanData == ScanDataType.Centroid || (scanEvent.ScanData == ScanDataType.Profile)) { try { var reaction = scanEvent.GetReaction(0); var precursorMass = reaction.PrecursorMass; if (precursorMass > maxMz) { maxMz = precursorMass; } if (precursorMass < minMz) { minMz = precursorMass; } } catch (ArgumentOutOfRangeException) { Log.Warn("No reaction found for scan " + scanNumber); } // trailer extra data list var trailerData = rawFile.GetTrailerExtraInformation(scanNumber); for (var i = 0; i < trailerData.Length; i++) { if (trailerData.Labels[i] == "Charge State:") { if (int.Parse(trailerData.Values[i]) > maxCharge) { maxCharge = int.Parse(trailerData.Values[i]); } if (int.Parse(trailerData.Values[i]) < minCharge) { minCharge = int.Parse(trailerData.Values[i]); } } } } } } if (minCharge == 100000000000000) { minCharge = 0; } foreach (KeyValuePair <string, int> entry in msTypes) { if (entry.Key.Equals(MSOrderType.Ms.ToString())) { metadata.addMSData(new CVTerm("PRIDE:0000481", "PRIDE", "Number of MS1 spectra", entry.Value.ToString())); } if (entry.Key.Equals(MSOrderType.Ms2.ToString())) { metadata.addMSData(new CVTerm("PRIDE:0000482", "PRIDE", "Number of MS2 spectra", entry.Value.ToString())); } if (entry.Key.Equals(MSOrderType.Ms3.ToString())) { metadata.addMSData(new CVTerm("PRIDE:0000483", "PRIDE", "Number of MS3 spectra", entry.Value.ToString())); } } metadata.addScanSetting(fragmentationType); metadata.addMSData(new CVTerm("PRIDE:0000472", "PRIDE", "MS min charge", minCharge.ToString())); metadata.addMSData(new CVTerm("PRIDE:0000473", "PRIDE", "MS max charge", maxCharge.ToString())); metadata.addMSData(new CVTerm("PRIDE:0000474", "PRIDE", "MS min RT", minTime.ToString())); metadata.addMSData(new CVTerm("PRIDE:0000475", "PRIDE", "MS max RT", maxTime.ToString())); metadata.addMSData(new CVTerm("PRIDE:0000476", "PRIDE", "MS min MZ", minMz.ToString())); metadata.addMSData(new CVTerm("PRIDE:0000477", "PRIDE", "MS max MZ", maxMz.ToString())); // Write the meta data to file var json = JsonConvert.SerializeObject(metadata); json.Replace("\r\n", "\n"); string metadataOutputPath; if (_outputDirectory == null) { metadataOutputPath = _metadataFileName; } else { metadataOutputPath = _outputDirectory + "/" + _metadataFileName + "-metadata.json"; } File.WriteAllText(metadataOutputPath, json); }
public static void RunSearch(QcParameters qcParameters, RawDataCollection rawData, IRawDataPlus rawFile) { string mgfFile = Path.Combine(qcParameters.QcSearchDataDirectory, Path.GetFileName(rawData.rawFileName) + ".mgf"); string outputFile = Path.Combine(qcParameters.QcSearchDataDirectory, Path.GetFileName(rawData.rawFileName) + ".pep.xml"); if (qcParameters.searchParameters.SearchAlgorithm == SearchAlgorithm.XTandem) { XTandem.RunXTandem(rawData, qcParameters.searchParameters, mgfFile, outputFile, genDecoy: true); } if (qcParameters.searchParameters.SearchAlgorithm == SearchAlgorithm.IdentiPy) { var pars = qcParameters.searchParameters; Identipy.RunIdentipy(rawData, rawFile, qcParameters.QcSearchDataDirectory, pars, writeMGF: false); } }
/// <inheritdoc /> public override void Write(IRawDataPlus rawFile, int firstScanNumber, int lastScanNumber) { ConfigureWriter(".mgf"); using (Writer) { Log.Info("Processing " + (lastScanNumber - firstScanNumber + 1) + " scans"); var lastScanProgress = 0; for (var scanNumber = firstScanNumber; scanNumber <= lastScanNumber; scanNumber++) { if (!ParseInput.Verbose) { var scanProgress = (int)((double)scanNumber / (lastScanNumber - firstScanNumber + 1) * 100); if (scanProgress % ProgressPercentageStep == 0) { if (scanProgress != lastScanProgress) { Console.Write("" + scanProgress + "% "); lastScanProgress = scanProgress; } } } // Get each scan from the RAW file var scan = Scan.FromFile(rawFile, scanNumber); // Check to see if the RAW file contains label (high-res) data and if it is present // then look for any data that is out of order var time = rawFile.RetentionTimeFromScanNumber(scanNumber); // Get the scan filter for this scan number var scanFilter = rawFile.GetFilterForScanNumber(scanNumber); // Get the scan event for this scan number var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); IReaction reaction = null; switch (scanFilter.MSOrder) { case MSOrderType.Ms: // Keep track of scan number for precursor reference _precursorScanNumber = scanNumber; break; case MSOrderType.Ms2: try { reaction = scanEvent.GetReaction(0); } catch (ArgumentOutOfRangeException exception) { Log.Warn("No reaction found for scan " + scanNumber); } goto default; case MSOrderType.Ms3: { try { reaction = scanEvent.GetReaction(1); } catch (ArgumentOutOfRangeException) { Log.Warn("No reaction found for scan " + scanNumber); } goto default; } default: Writer.WriteLine("BEGIN IONS"); Writer.WriteLine($"TITLE={ConstructSpectrumTitle(scanNumber)}"); Writer.WriteLine($"SCANS={scanNumber}"); Writer.WriteLine( $"RTINSECONDS={(time * 60).ToString(CultureInfo.InvariantCulture)}"); // trailer extra data list var trailerData = rawFile.GetTrailerExtraInformation(scanNumber); int? charge = null; double?monoisotopicMz = null; double?isolationWidth = null; for (var i = 0; i < trailerData.Length; i++) { if (trailerData.Labels[i] == "Charge State:") { if (Convert.ToInt32(trailerData.Values[i]) > 0) { charge = Convert.ToInt32(trailerData.Values[i]); } } if (trailerData.Labels[i] == "Monoisotopic M/Z:") { monoisotopicMz = double.Parse(trailerData.Values[i], NumberStyles.Any, CultureInfo.CurrentCulture); } if (trailerData.Labels[i] == "MS" + (int)scanFilter.MSOrder + " Isolation Width:") { isolationWidth = double.Parse(trailerData.Values[i], NumberStyles.Any, CultureInfo.CurrentCulture); } } if (reaction != null) { var selectedIonMz = CalculateSelectedIonMz(reaction, monoisotopicMz, isolationWidth); Writer.WriteLine("PEPMASS=" + selectedIonMz.ToString(CultureInfo.InvariantCulture)); } // charge if (charge != null) { // Scan polarity var polarity = PositivePolarity; if (scanFilter.Polarity == PolarityType.Negative) { polarity = NegativePolarity; } Writer.WriteLine($"CHARGE={charge}{polarity}"); } // write the filter string //Writer.WriteLine($"SCANEVENT={scanEvent.ToString()}"); // Check if the scan has a centroid stream if (scan.HasCentroidStream && (scanEvent.ScanData == ScanDataType.Centroid || (scanEvent.ScanData == ScanDataType.Profile && !ParseInput.NoPeakPicking))) { var centroidStream = rawFile.GetCentroidStream(scanNumber, false); if (scan.CentroidScan.Length > 0) { for (var i = 0; i < centroidStream.Length; i++) { Writer.WriteLine( centroidStream.Masses[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + centroidStream.Intensities[i].ToString("0.0000000000", CultureInfo.InvariantCulture)); } } } // Otherwise take the profile data else { // Get the scan statistics from the RAW file for this scan number var scanStatistics = rawFile.GetScanStatsForScanNumber(scanNumber); // Get the segmented (low res and profile) scan data var segmentedScan = rawFile.GetSegmentedScanFromScanNumber(scanNumber, scanStatistics); for (var i = 0; i < segmentedScan.Positions.Length; i++) { Writer.WriteLine( segmentedScan.Positions[i].ToString("0.0000000", CultureInfo.InvariantCulture) + " " + segmentedScan.Intensities[i].ToString("0.0000000000", CultureInfo.InvariantCulture)); } } Writer.WriteLine("END IONS"); Log.Debug("Spectrum written to file -- SCAN " + scanNumber); break; } } if (!ParseInput.Verbose) { Console.WriteLine(); } } }
public static MsDataScan GetOneBasedScan(IRawDataPlus rawFile, IFilteringParams filteringParams, int scanNumber) { var filter = rawFile.GetFilterForScanNumber(scanNumber); string scanFilterString = filter.ToString(); int msOrder = (int)filter.MSOrder; if (msOrder < 1 || msOrder > 10) { throw new MzLibException("Unknown MS Order (" + msOrder + ") for scan number " + scanNumber); } string nativeId = "controllerType=0 controllerNumber=1 scan=" + scanNumber; MzSpectrum spectrum = GetSpectrum(rawFile, filteringParams, scanNumber, scanFilterString, msOrder); var scanStats = rawFile.GetScanStatsForScanNumber(scanNumber); double scanRangeHigh = scanStats.HighMass; double scanRangeLow = scanStats.LowMass; MzRange scanWindowRange = new MzRange(scanRangeLow, scanRangeHigh); double? ionInjectionTime = null; double? precursorSelectedMonoisotopicIonMz = null; int? selectedIonChargeState = null; double? ms2IsolationWidth = null; int? precursorScanNumber = null; double? isolationMz = null; string HcdEnergy = null; ActivationType activationType = ActivationType.Any; var trailer = rawFile.GetTrailerExtraInformation(scanNumber); string[] labels = trailer.Labels; string[] values = trailer.Values; for (int i = 0; i < trailer.Labels.Length; i++) { if (labels[i].StartsWith("Ion Injection Time (ms)", StringComparison.Ordinal)) { ionInjectionTime = double.Parse(values[i], CultureInfo.InvariantCulture) == 0 ? (double?)null : double.Parse(values[i], CultureInfo.InvariantCulture); } if (msOrder < 2) { continue; } if (labels[i].StartsWith("MS" + msOrder + " Isolation Width", StringComparison.Ordinal)) { ms2IsolationWidth = double.Parse(values[i], CultureInfo.InvariantCulture) == 0 ? (double?)null : double.Parse(values[i], CultureInfo.InvariantCulture); } if (labels[i].StartsWith("Monoisotopic M/Z", StringComparison.Ordinal)) { precursorSelectedMonoisotopicIonMz = double.Parse(values[i], CultureInfo.InvariantCulture) == 0 ? (double?)null : double.Parse(values[i], CultureInfo.InvariantCulture); } if (labels[i].StartsWith("Charge State", StringComparison.Ordinal)) { selectedIonChargeState = int.Parse(values[i], CultureInfo.InvariantCulture) == 0 ? (int?)null : int.Parse(values[i], CultureInfo.InvariantCulture); } if (labels[i].StartsWith("Master Scan Number", StringComparison.Ordinal) || labels[i].StartsWith("Master Index", StringComparison.Ordinal)) { precursorScanNumber = int.Parse(values[i], CultureInfo.InvariantCulture) <= 1 ? (int?)null : int.Parse(values[i], CultureInfo.InvariantCulture); } if (labels[i].StartsWith("HCD Energy:", StringComparison.Ordinal)) { HcdEnergy = values[i]; } } if (msOrder > 1) { var scanEvent = rawFile.GetScanEventForScanNumber(scanNumber); var reaction = scanEvent.GetReaction(0); isolationMz = reaction.PrecursorMass; activationType = reaction.ActivationType; if (ms2IsolationWidth == null) { ms2IsolationWidth = reaction.IsolationWidth; } if (precursorScanNumber == null) { // we weren't able to get the precursor scan number, so we'll have to guess; // loop back to find precursor scan // (assumed to be the first scan before this scan with an MS order of this scan's MS order - 1) // e.g., if this is an MS2 scan, find the first MS1 scan before this and assume that's the precursor scan for (int i = scanNumber; i >= 1; i--) { var possiblePrecursorScanFilter = rawFile.GetFilterForScanNumber(i); int order = (int)possiblePrecursorScanFilter.MSOrder; if (order == msOrder - 1) { precursorScanNumber = i; break; } } if (precursorScanNumber == null) { throw new MzLibException("Could not get precursor for scan #" + scanNumber); } } } // at this point, we have the m/z value of the species that got fragmented, from the scan header // this section of the code finds that peak in the spectrum (it's actual intensity and centroided m/z values) // the intention is to remove any rounding issues caused by what is in the scan header and what is observable in the spectrum double?selectedIonIntensity = null; if (isolationMz.HasValue) { int?closest = spectrum.GetClosestPeakIndex(isolationMz.Value); if (closest.HasValue) { double mz = spectrum.XArray[closest.Value]; double intensity = spectrum.YArray[closest.Value]; if (Math.Abs(mz - isolationMz.Value) < 0.1) { selectedIonIntensity = intensity; isolationMz = mz; } } } return(new MsDataScan( massSpectrum: spectrum, oneBasedScanNumber: scanNumber, msnOrder: msOrder, isCentroid: true, polarity: GetPolarity(filter.Polarity), retentionTime: rawFile.RetentionTimeFromScanNumber(scanNumber), scanWindowRange: scanWindowRange, scanFilter: scanFilterString, mzAnalyzer: GetMassAnalyzerType(filter.MassAnalyzer), totalIonCurrent: spectrum.SumOfAllY, injectionTime: ionInjectionTime, noiseData: null, //TODO: implement reading noise data. it's unused right now, so it's just left as null nativeId: nativeId, selectedIonMz: isolationMz, selectedIonChargeStateGuess: selectedIonChargeState, selectedIonIntensity: selectedIonIntensity, isolationMZ: isolationMz, isolationWidth: ms2IsolationWidth, dissociationType: GetDissociationType(activationType), oneBasedPrecursorScanNumber: precursorScanNumber, selectedIonMonoisotopicGuessMz: precursorSelectedMonoisotopicIonMz, hcdEnergy: HcdEnergy)); }
public static ScanIndex ScanIndices(IRawDataPlus rawFile) { rawFile.SelectInstrument(Device.MS, 1); Log.Information("Extracting scan indices"); Dictionary <int, ScanData> allScans; allScans = new Dictionary <int, ScanData>(); MSOrderType AnalysisOrder; List <int> ms1 = new List <int>(); List <int> ms2 = new List <int>(); List <int> ms3 = new List <int>(); List <int> msAny = new List <int>(); // populate the scan indices IEnumerable <int> scans = rawFile.GetFilteredScanEnumerator(rawFile.GetFilterFromString("")); // get all scans ProgressIndicator P = new ProgressIndicator(scans.Count(), "Extracting scan indices"); foreach (int scan in scans) { IScanEvent scanEvent = rawFile.GetScanEventForScanNumber(scan); ScanData scanData = new ScanData(); scanData.MassAnalyzer = scanEvent.MassAnalyzer; scanData.MSOrder = scanEvent.MSOrder; allScans.Add(scan, scanData); msAny.Add(scan); if (allScans[scan].MSOrder == MSOrderType.Ms) { ms1.Add(scan); } if (allScans[scan].MSOrder == MSOrderType.Ms2) { ms2.Add(scan); } if (allScans[scan].MSOrder == MSOrderType.Ms3) { ms3.Add(scan); } P.Update(); } P.Done(); // determine the msorder of the experiment if ((ms1.Count > 0) & (ms2.Count == 0) & (ms3.Count == 0)) { AnalysisOrder = MSOrderType.Ms; } else { if ((ms1.Count > 0) & (ms2.Count > 0) & (ms3.Count == 0)) { AnalysisOrder = MSOrderType.Ms2; } else { AnalysisOrder = MSOrderType.Ms3; } } ScanIndex scanIndex = new ScanIndex(); scanIndex.allScans = allScans; scanIndex.AnalysisOrder = AnalysisOrder; scanIndex.ScanEnumerators.Add(MSOrderType.Any, msAny.ToArray()); scanIndex.ScanEnumerators.Add(MSOrderType.Ms, ms1.ToArray()); scanIndex.ScanEnumerators.Add(MSOrderType.Ms2, ms2.ToArray()); scanIndex.ScanEnumerators.Add(MSOrderType.Ms3, ms3.ToArray()); return(scanIndex); }
public static void Quantify(this QuantDataCollection quantData, RawDataCollection rawData, IRawDataPlus rawFile, string labelingReagent) { MassAnalyzerType quantAnalyzer = rawData.methodData.QuantAnalyzer; if (quantAnalyzer == MassAnalyzerType.MassAnalyzerFTMS) { rawData.ExtractCentroidStreams(rawFile, rawData.methodData.AnalysisOrder); } else { rawData.ExtractSegmentScans(rawFile, rawData.methodData.AnalysisOrder); } int[] scans; ScanIndex scanIndex = rawData.scanIndex; Dictionary <int, CentroidStreamData> centroidScans = rawData.centroidStreams; Dictionary <int, SegmentedScanData> segmentScans = rawData.segmentedScans; scans = scanIndex.ScanEnumerators[scanIndex.AnalysisOrder]; ProgressIndicator progress = new ProgressIndicator(scans.Length, "Quantifying reporter ions"); quantData.LabelingReagents = labelingReagent; foreach (int scan in scans) { if (quantAnalyzer == MassAnalyzerType.MassAnalyzerFTMS) { quantData.Add(scan, new QuantifyReporters(centroidScans[scan], labelingReagent).quantData); } else { quantData.Add(scan, new QuantifyReporters(segmentScans[scan], labelingReagent).quantData); } progress.Update(); } progress.Done(); rawData.Performed.Add(Operations.Quantification); }