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);
}
