/// <summary>
/// Initiates a dynamic connection with a Thermo .raw file. Data can be "streamed" instead of loaded all at once. Use
/// GetOneBasedScanFromDynamicConnection to get data from a particular scan. Use CloseDynamicConnection to close the
/// dynamic connection after all desired data has been retrieved from the dynamic connection.
/// </summary>
private void InitiateDynamicConnection(string filePath)
{
Loaders.LoadElements();
if (dynamicConnection != null)
{
dynamicConnection.Dispose();
}
dynamicConnection = RawFileReaderAdapter.FileFactory(filePath);
if (!File.Exists(filePath))
{
throw new FileNotFoundException();
}
if (!dynamicConnection.IsOpen)
{
throw new MzLibException("Unable to access RAW file!");
}
if (dynamicConnection.IsError)
{
throw new MzLibException("Error opening RAW file!");
}
if (dynamicConnection.InAcquisition)
{
throw new MzLibException("RAW file still being acquired!");
}
dynamicConnection.SelectInstrument(Device.MS, 1);
GetMsOrdersByScanInDynamicConnection();
}
//Console.ReadKey();
}
public static void getentityData(string resFilePath, string rawFile, string headerInfo, string paraIndex)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(rawFile);
plus.SelectInstrument(Device.MS, 1);
ArrayList indexOfpara = new ArrayList();
string[] selectIndex = paraIndex.Split(',');
foreach (string ele in selectIndex)
{
int index = Int32.Parse(ele);
indexOfpara.Add(index);
}
//string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(resFilePath, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
headerInfo = "RT," + headerInfo;
headerInfo = "#," + headerInfo;
writer.WriteLine(headerInfo);
int offset = 0;
int maxoffset = plus.GetStatusLogEntriesCount();
while (offset < maxoffset)
{
string temp = "";
IStatusLogEntry statusLogEntry = plus.GetStatusLogEntry(offset);
temp += offset.ToString() + ",";
temp += statusLogEntry.Time.ToString() + ",";
foreach (int ele in indexOfpara)
{
temp += Convert.ToString(statusLogEntry.Values[ele]) + ",";
}
writer.WriteLine(temp.Substring(0, temp.Length - 1));
offset += 1;
}
writer.Close();
}
public static void showheaderInfo(string filePath)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
HeaderItem[] statuslogheaderinformation = plus.GetStatusLogHeaderInformation();
int index = 0;
Console.OutputEncoding = Encoding.UTF8;
while (index < statuslogheaderinformation.Length)
{
Console.WriteLine(statuslogheaderinformation[index].Label);
//headerInfo[index] = statuslogheaderinformation[index].Label;
//writer.WriteLine(statuslogheaderinformation[index].Label);
index += 1;
}
//writer.Close();
//while (true)
//{
//if (index >= statuslogheaderinformation.Length)
//{
// Console.WriteLine(plus.RunHeaderEx.FirstSpectrum.ToString());
// Console.WriteLine(plus.RunHeaderEx.LastSpectrum.ToString());
// Console.WriteLine(plus.RunHeaderEx.StartTime.ToString("F2"));
// Console.WriteLine(plus.RunHeaderEx.EndTime.ToString("F2"));
// Console.WriteLine(plus.RunHeaderEx.LowMass.ToString());
// Console.WriteLine(plus.RunHeaderEx.HighMass.ToString());
// break;
//}
// Console.WriteLine(statuslogheaderinformation[index].Label);
// writer.WriteLine(statuslogheaderinformation[index].Label);
// index++;
//}
//writer.Close();
}
public static void getTuneInfo(string filePath)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".txt";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("*********************InstrumentMethod(0)***************************");
writer.WriteLine(plus.GetInstrumentMethod(0));
writer.WriteLine("*********************InstrumentMethod(1)****************************");
writer.WriteLine(plus.GetInstrumentMethod(1));
HeaderItem[] tuneDataHeaderInfo = plus.GetTuneDataHeaderInformation();
writer.WriteLine("*********************Tune DATA ****************************");
int tuneCnt = plus.GetTuneDataCount();
for (int i = 0; i < tuneDataHeaderInfo.Length; ++i)
{
writer.WriteLine(tuneDataHeaderInfo[i].Label);
}
writer.Close();
}
public static void getMSdataFromScanNum(int startNum, int endNum, string filePath, double lowMS = 0.00, double highMS = 0.00)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
//////////////////////////////////
plus.SelectInstrument(Device.MS, 1);
/////////////////////////////////
const string FilterStringIsolationMzPattern = @"ms2 (.*?)@";
int precursorMs1ScanNumber = 0;
double precursorMS= 0.00;
IReaction reaction = null;
var value = "";
var firstScanNumber = plus.RunHeaderEx.FirstSpectrum;
var lastScanNumber = plus.RunHeaderEx.LastSpectrum;
startNum = firstScanNumber;
endNum = lastScanNumber;
//int maxNum = plus.RunHeaderEx.LastSpectrum > endNum ? endNum : plus.RunHeaderEx.LastSpectrum;
LimitedSizeDictionary<string, int> precursorMs2ScanNumbers = new LimitedSizeDictionary<string, int>(40);
plus.SelectInstrument(Device.MS, 1);
if(highMS - 0.00 <= 0.01)
{
highMS = plus.RunHeaderEx.HighMass;
}
double maxMs = plus.RunHeaderEx.HighMass;
double minMs = plus.RunHeaderEx.LowMass;
lowMS = minMs;
highMS = maxMs;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("ScanNumber, RT, Mass, Resolution, Intensity, Noise, Filter,MSLevel,collisionEnergy, precursorNum,precursorMS");
while (startNum <= endNum)
{
var levelInfo = "";
var spectrumRef = "";
Scan scan = Scan.FromFile(plus, startNum);
IScanFilter scanFilter = plus.GetFilterForScanNumber(startNum);
IScanEvent scanEvent = plus.GetScanEventForScanNumber(startNum);
switch (scanFilter.MSOrder)
{
case MSOrderType.Ms:
// Keep track of scan number for precursor reference
precursorMs1ScanNumber = startNum;
reaction = scanEvent.GetReaction(0);
value = reaction.CollisionEnergy.ToString(CultureInfo.InvariantCulture).ToString();
levelInfo = scanFilter.MSOrder.ToString() + "," + "" + "," + "" + "," + "";
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, startNum);
}
spectrumRef = precursorMs1ScanNumber.ToString();
reaction = scanEvent.GetReaction(0);
value = reaction.CollisionEnergy.ToString(CultureInfo.InvariantCulture).ToString();
precursorMS = reaction.PrecursorMass;
levelInfo = scanFilter.MSOrder.ToString() + "," + value + "," + spectrumRef.ToString() + "," + precursorMS.ToString() ;
break;
case MSOrderType.Ms3:
var precursorMs2ScanNumber = precursorMs2ScanNumbers.Keys.FirstOrDefault(isolationMz => scanEvent.ToString().Contains(isolationMz));
spectrumRef = precursorMs2ScanNumbers[precursorMs2ScanNumber].ToString();
if (!precursorMs2ScanNumber.IsNullOrEmpty())
{
reaction = scanEvent.GetReaction(1);
}
else
{
throw new InvalidOperationException("Couldn't find a MS2 precursor scan for MS3 scan " + scanEvent);
}
precursorMS = reaction.PrecursorMass;
value = reaction.CollisionEnergy.ToString(CultureInfo.InvariantCulture).ToString();
levelInfo = scanFilter.MSOrder.ToString() + "," + value + "," + spectrumRef.ToString() + "," + precursorMS.ToString();
break;
default:
throw new ArgumentOutOfRangeException();
}
//var scanStatistics = plus.GetScanStatsForScanNumber(startNum);
//// Get the segmented (low res and profile) scan data
//var segmentedScan = plus.GetSegmentedScanFromScanNumber(startNum, scanStatistics);
//double[] masses = segmentedScan.Positions;
//double[] intensitis = segmentedScan.Intensities;
//Console.WriteLine(masses.Length);
//Console.WriteLine(intensitis.Length);
int cnt = 0;
if (scanFilter.MSOrder == MSOrderType.Ms)
{
while (cnt < scan.PreferredMasses.Length)
{
if (lowMS < scan.PreferredMasses[cnt] && scan.PreferredMasses[cnt] < highMS)
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
double msval = scan.PreferredMasses[cnt];
double resolution = (scan.PreferredResolutions.Length == 0) ? 0.0 : scan.PreferredResolutions[cnt];
double intensity = (scan.PreferredIntensities.Length == 0) ? 0.0 : scan.PreferredIntensities[cnt];
double noise = (scan.PreferredNoises.Length == 0) ? 0.0 : scan.PreferredNoises[cnt];
//msval.ToString("f4");Return a number to a given precision,carry bit
//msval.ToString("n4");Return a number to a given precision,not carry bit
//writer.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", startNum.ToString(), rt.ToString(),
// msval.ToString("n4"), resolution.ToString(), intensity.ToString(), noise.ToString(),
// scanFilter.ToString(), levelInfo);
writer.WriteLine("{0},{1},{2},{3}", startNum.ToString(), rt.ToString(), msval.ToString(), intensity.ToString());
}
cnt += 1;
}
}
writer.Flush();
startNum += 1;
}
writer.Close();
}
public static void getMSdataFromRT(double startRT, int endRT, string filePath, double lowMS = 0.00, double highMS = 0.00)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
if (highMS - 0.00 <= 0.01)
{
highMS = plus.RunHeaderEx.HighMass;
}
int startNum = plus.ScanNumberFromRetentionTime(startRT);
int endNum = plus.ScanNumberFromRetentionTime(endRT);
int maxNum = plus.RunHeaderEx.LastSpectrum > endNum ? endNum : plus.RunHeaderEx.LastSpectrum;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("ScanNumber, RT, Mass, Resolution, Intensity, Noise, Filter");
while (startNum <= endNum)
{
Scan scan = Scan.FromFile(plus, startNum);
string filter = plus.GetFilterForScanNumber(startNum).ToString();
int cnt = 0;
while (cnt < scan.PreferredMasses.Length)
{
if (lowMS < scan.PreferredMasses[cnt] && scan.PreferredMasses[cnt] < highMS)
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
double msval = scan.PreferredMasses[cnt];
double resolution = (scan.PreferredResolutions.Length == 0) ? 0.0 : scan.PreferredResolutions[cnt];
double intensity = (scan.PreferredIntensities.Length == 0) ? 0.0 : scan.PreferredIntensities[cnt];
double noise = (scan.PreferredNoises.Length == 0) ? 0.0 : scan.PreferredNoises[cnt];
//writer.WriteLine("{0},{1},{2},{3},{4},{5},{6}", startNum.ToString(), rt.ToString(), msval.ToString(), resolution.ToString(), intensity.ToString(), noise.ToString(), filter.ToString());
/// <summary>
/// Get and set general information from the raw file
/// </summary>
/// <param name="inputRawFile"></param>
/// <returns></returns>
private IRawDataPlus GetSetRawFileData(string inputRawFile)
{
// Create the IRawDataPlus object for accessing the RAW file
IRawDataPlus rawFile = RawFileReaderAdapter.FileFactory(inputRawFile);
if (!rawFile.IsOpen || rawFile.IsError)
{
Console.WriteLine("Unable to access the RAW file using the RawFileReader class!");
}
// Check for any errors in the RAW file
if (rawFile.IsError)
{
Console.WriteLine("Error opening ({0})", rawFile.FileError);
}
// Check if the RAW file is being acquired
if (rawFile.InAcquisition)
{
Console.WriteLine("RAW file still being acquired...");
}
// Select instrument we are intereted in looking at data from
rawFile.SelectInstrument(Device.MS, 1);
return(rawFile);
}
public static PrecursorMassCollection PrecursorMasses(IRawDataPlus rawFile, PrecursorScanCollection precursorScans, TrailerExtraCollection trailerExtras, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting precursor masses");
PrecursorMassCollection precursorMasses = new PrecursorMassCollection();
var scans = index.ScanEnumerators[MSOrderType.Any];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Extracting precursor masses");
foreach (int scan in scans)
{
if (index.allScans[scan].MSOrder == MSOrderType.Ms2)
{
double parent_mass = rawFile.GetScanEventForScanNumber(scan).GetReaction(0).PrecursorMass;
precursorMasses[scan] = new PrecursorMassData(trailerExtras[scan].MonoisotopicMZ, parent_mass);
}
if (index.allScans[scan].MSOrder == MSOrderType.Ms3)
{
int ms2scan = precursorScans[scan].MS2Scan;
double parent_mass = rawFile.GetScanEventForScanNumber(scan).GetReaction(0).PrecursorMass;
precursorMasses[scan] = new PrecursorMassData(trailerExtras[ms2scan].MonoisotopicMZ, parent_mass);
}
progress.Update();
}
progress.Done();
return(precursorMasses);
}
/// <summary>
/// Gets precursor scans directly from the trailer extra. This is intended for DIA files, and by extension only for Ms2 experiments.
/// </summary>
/// <param name="rawFile"></param>
/// <param name="index"></param>
/// <returns></returns>
public static PrecursorScanCollection PrecursorScansByMasterScanMs2Only(IRawDataPlus rawFile, TrailerExtraCollection trailerExtras, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting scan dependents/precursor scans");
PrecursorScanCollection precursorScans = new PrecursorScanCollection();
int ms2Scan = -1;
int ms3Scan = -1;
IEnumerable <int> scans = index.ScanEnumerators[MSOrderType.Ms];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Indexing linked scan events");
// if it is DIA it must be MS2
scans = index.ScanEnumerators[MSOrderType.Ms2];
foreach (int scan in scans)
{
int masterScan = trailerExtras[scan].MasterScan;
precursorScans[scan] = new PrecursorScanData(ms2scan: scan, masterScan: masterScan);
}
progress.Done();
return(precursorScans);
}
public static void QcDIA(IRawDataPlus rawFile, WorkflowParameters parameters)
{
rawFile.SelectInstrument(Device.MS, 1);
rawFile.CheckIfBoxcar();
ScanIndex Index = Extract.ScanIndices(rawFile);
MethodDataContainer methodData = Extract.MethodData(rawFile, Index);
CentroidStreamCollection centroidStreams = new CentroidStreamCollection();
SegmentScanCollection segmentScans = new SegmentScanCollection();
(centroidStreams, segmentScans) = Extract.MsData(rawFile: rawFile, index: Index);
TrailerExtraCollection trailerExtras = Extract.TrailerExtras(rawFile, Index);
RetentionTimeCollection retentionTimes = Extract.RetentionTimes(rawFile, Index);
ScanMetaDataCollectionDIA metaData = MetaDataProcessingDIA.AggregateMetaDataDIA(centroidStreams, segmentScans, methodData,
trailerExtras, retentionTimes, Index);
RawMetricsDataDIA metrics = MetaDataProcessingDIA.GetMetricsDataDIA(metaData, methodData, rawFile.FileName, retentionTimes, Index);
QcDataContainer qcData = new QcDataContainer();
qcData.DIA = metrics;
QcDataCollection qcDataCollection = QC.QcWorkflow.LoadOrCreateQcCollection(parameters);
QC.QcWorkflow.UpdateQcCollection(qcDataCollection, qcData, methodData, rawFile.FileName);
}
DependentsAndPrecursorScansByScanDependents(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting scan dependents/precursor scans");
PrecursorScanCollection precursorScans = new PrecursorScanCollection();
ScanDependentsCollections dependents = new ScanDependentsCollections();
int ms2Scan = -1;
int ms3Scan = -1;
IEnumerable <int> scans = index.ScanEnumerators[MSOrderType.Ms];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Indexing linked scan events");
foreach (int scan in scans)
{
var scanDependents = rawFile.GetScanDependents(scan, 4);
dependents[scan] = scanDependents;
// check if the ms1 scan has dependent scans
if (scanDependents == null)
{
continue;
}
for (int i = 0; i < scanDependents.ScanDependentDetailArray.Length; i++)
{
if (index.AnalysisOrder == MSOrderType.Ms2) // it is ms2
{
ms2Scan = scanDependents.ScanDependentDetailArray[i].ScanIndex;
precursorScans[ms2Scan] = new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan);
}
else // it is ms3
{
ms2Scan = scanDependents.ScanDependentDetailArray[i].ScanIndex;
var ms2Dependents = rawFile.GetScanDependents(ms2Scan, 4).ScanDependentDetailArray;
if (ms2Dependents.Length != 0) // make sure there is ms3 data
{
ms3Scan = ms2Dependents[0].ScanIndex;
precursorScans[ms2Scan] = new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan);
precursorScans[ms3Scan] = new PrecursorScanData(ms3scan: ms3Scan, ms2Scan: ms2Scan, masterScan: scan);
}
else
{
// there is no ms3 scan, so we only add the ms2 scan
precursorScans[ms2Scan] = new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan);
}
}
}
progress.Update();
}
progress.Done();
return(precursorScans, dependents);
}
/// <summary>
/// Calculate the precursor peak 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>
protected static double?CalculatePrecursorPeakIntensity(IRawDataPlus rawFile, int precursorScanNumber,
double precursorMass)
{
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);
IChromatogramSettings[] allSettings =
{
new ChromatogramTraceSettings(TraceType.BasePeak)
{
Filter = MsFilter,
MassRanges = new[]
{
new Range(precursorMass, precursorMass)
}
}
};
var data = rawFile.GetChromatogramData(allSettings, precursorScanNumber,
precursorScanNumber);
var chromatogramTrace = ChromatogramSignal.FromChromatogramData(data);
if (!chromatogramTrace.IsNullOrEmpty())
{
precursorIntensity = chromatogramTrace[0].Intensities[0];
}
}
return(precursorIntensity);
}
public static ScanDependentsCollections ScanDependents(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
ScanDependentsCollections scanDependents = new ScanDependentsCollections();
foreach (int scan in index.ScanEnumerators[MSOrderType.Ms])
{
scanDependents[scan] = rawFile.GetScanDependents(scan, 4);
}
return(scanDependents);
}
public static MethodDataContainer MethodData(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting method/instrument information");
MethodDataContainer methodData = new MethodDataContainer();
methodData.CreationDate = rawFile.CreationDate;
methodData.Instrument = rawFile.GetInstrumentData().Name;
methodData.AnalysisOrder = index.AnalysisOrder;
int firstQuantScan = index.ScanEnumerators[index.AnalysisOrder][0];
methodData.QuantAnalyzer = index.allScans[firstQuantScan].MassAnalyzer;
int firstMs1Scan = index.ScanEnumerators[MSOrderType.Ms][0];
methodData.MassAnalyzers.Add(MSOrderType.Ms, index.allScans[firstMs1Scan].MassAnalyzer);
methodData.MSOrderEnumerator.Add(MSOrderType.Ms);
if (methodData.AnalysisOrder == MSOrderType.Ms2)
{
int firstMs2Scan = index.ScanEnumerators[MSOrderType.Ms2][0];
methodData.MassAnalyzers.Add(MSOrderType.Ms2, index.allScans[firstMs2Scan].MassAnalyzer);
methodData.MSOrderEnumerator.Add(MSOrderType.Ms2);
}
else if (methodData.AnalysisOrder == MSOrderType.Ms3)
{
int firstMs2Scan = index.ScanEnumerators[MSOrderType.Ms2][0];
methodData.MassAnalyzers.Add(MSOrderType.Ms2, index.allScans[firstMs2Scan].MassAnalyzer);
methodData.MSOrderEnumerator.Add(MSOrderType.Ms2);
int n = index.ScanEnumerators[MSOrderType.Ms2].Count();
double ms2window = rawFile.GetScanEventForScanNumber(index.ScanEnumerators[MSOrderType.Ms2][n / 2]).GetIsolationWidth(0);
int firstMs3Scan = index.ScanEnumerators[MSOrderType.Ms3][0];
methodData.MassAnalyzers.Add(MSOrderType.Ms3, index.allScans[firstMs3Scan].MassAnalyzer);
methodData.MSOrderEnumerator.Add(MSOrderType.Ms3);
double ms3ms1window = rawFile.GetScanEventForScanNumber(firstMs3Scan).GetIsolationWidth(0);
double ms3ms2window = rawFile.GetScanEventForScanNumber(firstMs3Scan).GetIsolationWidth(1);
methodData.IsolationWindow = (MS2 : ms2window, (MS1Window : ms3ms1window, MS2Window : ms3ms2window));
}
else
{
Console.WriteLine("This raw file contains only MS1 scans.");
}
return(methodData);
}
public static void CheckIfBoxcar(this IRawDataPlus rawFile)
{
rawFile.SelectInstrument(Device.MS, 1);
bool isBoxCar = rawFile.GetScanEventForScanNumber(1).MassRangeCount > 1;
if (isBoxCar)
{
Log.Error("Boxcar experiments not currently supported");
Console.WriteLine("This looks like a boxcar or similar raw file. Sorry, boxcar is not currently supported.");
Environment.Exit(0);
}
else
{
return;
}
}
/// <summary>
/// Open new Raw file with warning messages.
/// </summary>
/// <param name="path"></param>
public void Open(string path)
{
rawFile = RawFileReaderAdapter.FileFactory(path);
if (!rawFile.IsOpen)
{
Console.WriteLine(" RawFile Error: File could not be opened: " + path);
Console.WriteLine(rawFile.FileError.WarningMessage);
Console.WriteLine(rawFile.FileError.ErrorMessage);
Console.WriteLine(rawFile.FileError.ErrorCode);
throw new IOException("Failed to open RAW file.");
}
if (rawFile.IsError)
{
Console.WriteLine(" RawFile Error: reader error: " + path);
throw new IOException("Error while opening RAW file.");
}
rawFile.SelectInstrument(ThermoBiz.Device.MS, 1);
rawFile.IncludeReferenceAndExceptionData = true;
}
public static (CentroidStreamCollection centroids, SegmentScanCollection segments) MsData(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
CentroidStreamCollection centroids = new CentroidStreamCollection();
SegmentScanCollection segments = new SegmentScanCollection();
CentroidStream centroid;
SegmentedScan segment;
var scans = index.allScans;
//var lockTarget = new object(); // this is so we can keep track of progress in the parallel loop
ProgressIndicator P = new ProgressIndicator(scans.Count(), "Extracting scan data");
P.Start();
foreach (int scan in scans.Keys)
{
// first get out the mass spectrum
if (index.allScans[scan].MassAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
centroid = rawFile.GetCentroidStream(scan, false);
centroids[scan] = new CentroidStreamData(centroid);
}
else
{
segment = rawFile.GetSegmentedScanFromScanNumber(scan, null);
segments[scan] = new SegmentedScanData(segment);
}
//lock (lockTarget)
//{
// P.Update();
//}
P.Update();
}
P.Done();
return(centroids, segments);
}
public static RetentionTimeCollection RetentionTimes(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting retention times");
RetentionTimeCollection retentionTimes = new RetentionTimeCollection();
var scans = index.ScanEnumerators[MSOrderType.Any];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Extracting retention times");
foreach (int scan in scans)
{
retentionTimes[scan] = rawFile.RetentionTimeFromScanNumber(scan);
progress.Update();
}
progress.Done();
return(retentionTimes);
}
/// <summary>
/// Initiates a dynamic connection with a Thermo .raw file. Data can be "streamed" instead of loaded all at once. Use
/// GetOneBasedScanFromDynamicConnection to get data from a particular scan. Use CloseDynamicConnection to close the
/// dynamic connection after all desired data has been retrieved from the dynamic connection.
/// </summary>
protected override void InitiateDynamicConnection()
{
if (!File.Exists(FilePath))
{
throw new FileNotFoundException();
}
if (Path.GetExtension(FilePath).ToUpper() != ".RAW")
{
throw new InvalidDataException();
}
Loaders.LoadElements();
if (dynamicConnection != null)
{
dynamicConnection.Dispose();
}
dynamicConnection = RawFileReaderAdapter.FileFactory(FilePath);
if (!dynamicConnection.IsOpen)
{
throw new MzLibException("Unable to access RAW file!");
}
if (dynamicConnection.IsError)
{
throw new MzLibException("Error opening RAW file!");
}
if (dynamicConnection.InAcquisition)
{
throw new MzLibException("RAW file still being acquired!");
}
dynamicConnection.SelectInstrument(Device.MS, 1);
GetMsOrdersByScanInDynamicConnection();
}
public Rawfile(string rawfile)
{
int deviceNumber = 1;
_rawfile = rawfile;
rawFile = RawFileReaderAdapter.FileFactory(_rawfile);
// https://github.com/cpanse/MsBackendRawFileReader/issues/12
rawFile.IncludeReferenceAndExceptionData = false;
rawFile.SelectInstrument(Device.MS, deviceNumber);
dictInfo.Add("filename", rawFile.FileName);
dictInfo.Add("creation date", rawFile.FileHeader.CreationDate.ToString());
dictInfo.Add("first scan", this.GetFirstScanNumber().ToString());
dictInfo.Add("last scan", this.GetLastScanNumber().ToString());
dictInfo.Add("model", rawFile.GetInstrumentData().Model.ToString());
dictInfo.Add("name", rawFile.GetInstrumentData().Name.ToString());
dictInfo.Add("SerialNumber", rawFile.GetInstrumentData().SerialNumber.ToString());
//dictInfo.Add("mass resolution", rawFile.RunHeaderEx.MassResolution.ToString());
var trailerData = rawFile.GetTrailerExtraInformation(rawFile.RunHeaderEx.FirstSpectrum);
foreach (int i in Enumerable.Range(1, trailerData.Labels.ToArray().Length))
{
try
{
if ((trailerData.Labels[i] == "Master Scan Number:") ||
(trailerData.Labels[i] == "Master Scan Number") ||
(trailerData.Labels[i] == "Master Index:"))
{
this.masterScanIdx = i;
}
}
catch
{
}
}
}
public static TrailerExtraCollection TrailerExtras(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting trailer extras");
TrailerExtraCollection trailerExtras = new TrailerExtraCollection();
TrailerExtraIndices trailerIndices = new TrailerExtraIndices(rawFile);
Double[] spsMasses;
var scans = index.ScanEnumerators[MSOrderType.Any];
ProgressIndicator P = new ProgressIndicator(scans.Count(), "Extracting trailer extras");
P.Start();
foreach (int scan in scans)
{
trailerExtras[scan] = ExtractOneTrailerExtra(rawFile, scan, trailerIndices);
P.Update();
}
P.Done();
return(trailerExtras);
}
public static MethodDataContainer Ms1MethodData(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting method/instrument information");
MethodDataContainer methodData = new MethodDataContainer();
methodData.CreationDate = rawFile.CreationDate;
methodData.Instrument = rawFile.GetInstrumentData().Name;
methodData.AnalysisOrder = index.AnalysisOrder;
int firstQuantScan = index.ScanEnumerators[index.AnalysisOrder][0];
methodData.QuantAnalyzer = index.allScans[firstQuantScan].MassAnalyzer;
int firstMs1Scan = index.ScanEnumerators[MSOrderType.Ms][0];
methodData.MassAnalyzers.Add(MSOrderType.Ms, index.allScans[firstMs1Scan].MassAnalyzer);
methodData.MSOrderEnumerator.Add(MSOrderType.Ms);
return(methodData);
}
/// <summary>
/// Loads all scan data from a Thermo .raw file.
/// </summary>
public static ThermoRawFileReader 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 ThermoRawFileReader(msDataScans, sourceFile));
}
static int DoStuff(ArgumentParser.ParseOptions 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));
}
if (opts.Quant)
{
List <string> possible = new List <string>()
{
"TMT0", "TMT2", "TMT6", "TMT10", "TMT11", "iTRAQ4", "iTRAQ8"
};
if (!possible.Contains(opts.LabelingReagents))
{
Console.WriteLine("ERROR: For quantification, the labeling reagent must be one of {TMT0, TMT2, TMT6, TMT10, TMT11, iTRAQ4, iTRAQ8}");
Log.Error("Invalid labeling reagent provided: {0}", opts.LabelingReagents);
return(1);
}
}
if (opts.Chromatogram != null)
{
List <string> possible = new List <string>()
{
"1T", "2T", "3T", "1B", "2B", "3B", "1TB", "2TB", "3TB", "1TB", "2TB", "3TB"
};
if (!possible.Contains(opts.Chromatogram))
{
Console.WriteLine("ERROR: Incorrect format for --chro. See help.");
Log.Error("Invalid chromatogram argument provided: {Chro}", opts.Chromatogram);
return(1);
}
}
System.Diagnostics.Stopwatch singleFileTime = new System.Diagnostics.Stopwatch();
System.Diagnostics.Stopwatch totalTime = new System.Diagnostics.Stopwatch();
totalTime.Start();
foreach (string file in files)
{
singleFileTime.Start();
Console.WriteLine("\nProcessing: {0}\n", file);
using (IRawDataPlus rawFile = RawFileReaderFactory.ReadFile(fileName: file))
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Now processing: {File} --- Instrument: {Instrument}", Path.GetFileName(file), rawFile.GetInstrumentData().Name);
RawDataCollection rawData = new RawDataCollection(rawFile: rawFile);
QuantDataCollection quantData = new QuantDataCollection();
bool isBoxCar = rawData.isBoxCar;
if (rawData.isBoxCar)
{
Console.WriteLine("\nRaw file appears to be a boxcar-type experiment. Precursor peak analysis won't be performed!\n");
}
if (opts.ParseData | opts.Metrics | opts.Quant)
{
rawData.ExtractAll(rawFile);
if (!isBoxCar)
{
rawData.CalcPeakRetTimesAndInts(rawFile: rawFile);
}
}
if (opts.Quant)
{
rawData.quantData.Quantify(rawData: rawData, rawFile: rawFile, labelingReagent: opts.LabelingReagents);
}
if (opts.UnlabeledQuant & !isBoxCar)
{
rawData.QuantifyPrecursorPeaks(rawFile);
}
if (opts.Metrics)
{
rawData.metaData.AggregateMetaData(rawData, rawFile);
}
if (opts.ParseData | opts.Quant)
{
if (opts.Quant)
{
Parse.WriteMatrix(rawData: rawData, rawFile: rawFile, metaData: rawData.metaData, quantData: rawData.quantData, outputDirectory: opts.OutputDirectory);
}
else
{
Parse.WriteMatrix(rawData: rawData, rawFile: rawFile, metaData: rawData.metaData, outputDirectory: opts.OutputDirectory);
}
}
if (opts.WriteMGF)
{
MGF.WriteMGF(rawData: rawData, rawFile: rawFile, outputDirectory: opts.OutputDirectory, cutoff: opts.MassCutOff,
intensityCutoff: opts.IntensityCutoff);
}
if (opts.Metrics)
{
MetricsData metricsData = new MetricsData();
if (opts.Quant)
{
metricsData.GetMetricsData(metaData: rawData.metaData, rawData: rawData, rawFile: rawFile, quantData: rawData.quantData);
}
else
{
metricsData.GetMetricsData(metaData: rawData.metaData, rawData: rawData, rawFile: rawFile);
}
metricsData.GetMetricsData(metaData: rawData.metaData, rawData: rawData, rawFile: rawFile);
Metrics.WriteMatrix(rawData, metricsData, opts.OutputDirectory);
}
if (opts.Chromatogram != null)
{
int order = Convert.ToInt32((opts.Chromatogram.ElementAt(0).ToString()));
if (order > (int)rawData.methodData.AnalysisOrder)
{
Log.Error("Specified MS order ({Order}) for chromatogram is higher than experiment order ({ExpOrder})",
(MSOrderType)order, rawData.methodData.AnalysisOrder);
Console.WriteLine("Specified MS order ({0}) for chromatogram is higher than experiment order ({1}). Chromatogram(s) won't be written.",
(MSOrderType)order, rawData.methodData.AnalysisOrder);
}
else
{
rawData.WriteChromatogram(rawFile, (MSOrderType)order, opts.Chromatogram.Contains("T"), opts.Chromatogram.Contains("B"), opts.OutputDirectory);
}
}
}
singleFileTime.Stop();
Console.WriteLine("\nElapsed time: {0} s", Math.Round(Convert.ToDouble(singleFileTime.ElapsedMilliseconds) / 1000.0, 2));
singleFileTime.Reset();
}
totalTime.Stop();
Console.WriteLine("\nTime to process all {0} files: {1}", files.Count(), totalTime.Elapsed);
return(0);
}
//int maxNum = plus.RunHeaderEx.LastSpectrum > endNum ? endNum : plus.RunHeaderEx.LastSpectrum;
LimitedSizeDictionary<string, int> precursorMs2ScanNumbers = new LimitedSizeDictionary<string, int>(40);
plus.SelectInstrument(Device.MS, 1);
if(highMS - 0.00 <= 0.01)
{
highMS = plus.RunHeaderEx.HighMass;
}
double maxMs = plus.RunHeaderEx.HighMass;
double minMs = plus.RunHeaderEx.LowMass;
lowMS = minMs;
highMS = maxMs;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("ScanNumber, RT, Mass, Resolution, Intensity, Noise, Filter,MSLevel,collisionEnergy, precursorNum,precursorMS");
while (startNum <= endNum)
{
var levelInfo = "";
var spectrumRef = "";
Scan scan = Scan.FromFile(plus, startNum);
IScanFilter scanFilter = plus.GetFilterForScanNumber(startNum);
IScanEvent scanEvent = plus.GetScanEventForScanNumber(startNum);
switch (scanFilter.MSOrder)
{
case MSOrderType.Ms:
// Keep track of scan number for precursor reference
precursorMs1ScanNumber = startNum;
reaction = scanEvent.GetReaction(0);
value = reaction.CollisionEnergy.ToString(CultureInfo.InvariantCulture).ToString();
levelInfo = scanFilter.MSOrder.ToString() + "," + "" + "," + "" + "," + "";
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, startNum);
}
spectrumRef = precursorMs1ScanNumber.ToString();
reaction = scanEvent.GetReaction(0);
value = reaction.CollisionEnergy.ToString(CultureInfo.InvariantCulture).ToString();
precursorMS = reaction.PrecursorMass;
levelInfo = scanFilter.MSOrder.ToString() + "," + value + "," + spectrumRef.ToString() + "," + precursorMS.ToString() ;
break;
case MSOrderType.Ms3:
var precursorMs2ScanNumber = precursorMs2ScanNumbers.Keys.FirstOrDefault(isolationMz => scanEvent.ToString().Contains(isolationMz));
spectrumRef = precursorMs2ScanNumbers[precursorMs2ScanNumber].ToString();
if (!precursorMs2ScanNumber.IsNullOrEmpty())
{
reaction = scanEvent.GetReaction(1);
}
else
{
throw new InvalidOperationException("Couldn't find a MS2 precursor scan for MS3 scan " + scanEvent);
}
precursorMS = reaction.PrecursorMass;
value = reaction.CollisionEnergy.ToString(CultureInfo.InvariantCulture).ToString();
levelInfo = scanFilter.MSOrder.ToString() + "," + value + "," + spectrumRef.ToString() + "," + precursorMS.ToString();
break;
default:
throw new ArgumentOutOfRangeException();
}
//var scanStatistics = plus.GetScanStatsForScanNumber(startNum);
//// Get the segmented (low res and profile) scan data
//var segmentedScan = plus.GetSegmentedScanFromScanNumber(startNum, scanStatistics);
//var masses = segmentedScan.Positions;
//var intensitis = segmentedScan.Intensities;
//Console.WriteLine(masses.Length);
//Console.WriteLine(intensitis.Length);
//Console.WriteLine(filterObj.MSOrder);
int cnt = 0;
while(cnt < scan.PreferredMasses.Length)
{
if(lowMS < scan.PreferredMasses[cnt] && scan.PreferredMasses[cnt] < highMS )
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
double msval = scan.PreferredMasses[cnt];
double resolution = (scan.PreferredResolutions.Length == 0) ? 0.0 : scan.PreferredResolutions[cnt];
double intensity = (scan.PreferredIntensities.Length == 0) ? 0.0 : scan.PreferredIntensities[cnt];
double noise = (scan.PreferredNoises.Length == 0) ? 0.0 : scan.PreferredNoises[cnt];
writer.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", startNum.ToString(), rt.ToString(),
msval.ToString(), resolution.ToString(), intensity.ToString(), noise.ToString(),
scanFilter.ToString(), levelInfo);
}
cnt += 1;
}
startNum += 1;
}
writer.Close();
}
public static void getMSdataFromRT(double startRT, int endRT, string filePath, double lowMS = 0.00, double highMS = 0.00)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
if (highMS - 0.00 <= 0.01)
{
highMS = plus.RunHeaderEx.HighMass;
}
int startNum = plus.ScanNumberFromRetentionTime(startRT);
int endNum = plus.ScanNumberFromRetentionTime(endRT);
int maxNum = plus.RunHeaderEx.LastSpectrum > endNum ? endNum : plus.RunHeaderEx.LastSpectrum;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("ScanNumber, RT, Mass, Resolution, Intensity, Noise, Filter");
while (startNum <= endNum)
{
Scan scan = Scan.FromFile(plus, startNum);
string filter = plus.GetFilterForScanNumber(startNum).ToString();
int cnt = 0;
while (cnt < scan.PreferredMasses.Length)
{
if (lowMS < scan.PreferredMasses[cnt] && scan.PreferredMasses[cnt] < highMS)
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
double msval = scan.PreferredMasses[cnt];
double resolution = (scan.PreferredResolutions.Length == 0) ? 0.0 : scan.PreferredResolutions[cnt];
double intensity = (scan.PreferredIntensities.Length == 0) ? 0.0 : scan.PreferredIntensities[cnt];
double noise = (scan.PreferredNoises.Length == 0) ? 0.0 : scan.PreferredNoises[cnt];
writer.WriteLine("{0},{1},{2},{3},{4},{5},{6}", startNum.ToString(), rt.ToString(), msval.ToString(), resolution.ToString(), intensity.ToString(), noise.ToString(), filter.ToString());
}
cnt += 1;
}
startNum += 1;
}
writer.Close();
}
}
}
writer.Flush();
startNum += 1;
}
writer.Close();
}
public static void getMSdataFromRT(double startRT, int endRT, string filePath, double lowMS = 0.00, double highMS = 0.00)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
if (highMS - 0.00 <= 0.01)
{
highMS = plus.RunHeaderEx.HighMass;
}
int startNum = plus.ScanNumberFromRetentionTime(startRT);
int endNum = plus.ScanNumberFromRetentionTime(endRT);
int maxNum = plus.RunHeaderEx.LastSpectrum > endNum ? endNum : plus.RunHeaderEx.LastSpectrum;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("ScanNumber, RT, Mass, Resolution, Intensity, Noise, Filter");
while (startNum <= endNum)
{
Scan scan = Scan.FromFile(plus, startNum);
string filter = plus.GetFilterForScanNumber(startNum).ToString();
int cnt = 0;
while (cnt < scan.PreferredMasses.Length)
{
if (lowMS < scan.PreferredMasses[cnt] && scan.PreferredMasses[cnt] < highMS)
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
double msval = scan.PreferredMasses[cnt];
double resolution = (scan.PreferredResolutions.Length == 0) ? 0.0 : scan.PreferredResolutions[cnt];
double intensity = (scan.PreferredIntensities.Length == 0) ? 0.0 : scan.PreferredIntensities[cnt];
double noise = (scan.PreferredNoises.Length == 0) ? 0.0 : scan.PreferredNoises[cnt];
//writer.WriteLine("{0},{1},{2},{3},{4},{5},{6}", startNum.ToString(), rt.ToString(), msval.ToString(), resolution.ToString(), intensity.ToString(), noise.ToString(), filter.ToString());
writer.WriteLine("{0},{1},{2},{3}", startNum.ToString(), rt.ToString(), msval.ToString(), intensity.ToString());
}
cnt += 1;
}
startNum += 1;
}
writer.Close();
}
public static void getSRMIacdMZ(string filePath, double valMS,int recVal)
}
}
writer.Flush();
startNum += 1;
}
writer.Close();
}
public static void getMSdataFromRT(double startRT, int endRT, string filePath, double lowMS = 0.00, double highMS = 0.00)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
if (highMS - 0.00 <= 0.01)
{
highMS = plus.RunHeaderEx.HighMass;
}
int startNum = plus.ScanNumberFromRetentionTime(startRT);
int endNum = plus.ScanNumberFromRetentionTime(endRT);
int maxNum = plus.RunHeaderEx.LastSpectrum > endNum ? endNum : plus.RunHeaderEx.LastSpectrum;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("ScanNumber, RT, Mass, Resolution, Intensity, Noise, Filter");
while (startNum <= endNum)
{
Scan scan = Scan.FromFile(plus, startNum);
string filter = plus.GetFilterForScanNumber(startNum).ToString();
int cnt = 0;
while (cnt < scan.PreferredMasses.Length)
{
if (lowMS < scan.PreferredMasses[cnt] && scan.PreferredMasses[cnt] < highMS)
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
double msval = scan.PreferredMasses[cnt];
double resolution = (scan.PreferredResolutions.Length == 0) ? 0.0 : scan.PreferredResolutions[cnt];
double intensity = (scan.PreferredIntensities.Length == 0) ? 0.0 : scan.PreferredIntensities[cnt];
double noise = (scan.PreferredNoises.Length == 0) ? 0.0 : scan.PreferredNoises[cnt];
//writer.WriteLine("{0},{1},{2},{3},{4},{5},{6}", startNum.ToString(), rt.ToString(), msval.ToString(), resolution.ToString(), intensity.ToString(), noise.ToString(), filter.ToString());
writer.WriteLine("{0},{1},{2},{3}", startNum.ToString(), rt.ToString(), msval.ToString(), intensity.ToString());
}
cnt += 1;
}
startNum += 1;
}
writer.Close();
}
public static void getSRMIacdMZ(string filePath, double valMS,int recVal)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
//////////////////////////////////
plus.SelectInstrument(Device.MS, 1);
/////////////////////////////////
var startNum = plus.RunHeaderEx.FirstSpectrum;
var endNum = plus.RunHeaderEx.LastSpectrum;
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
double[] masses = null;
double[] intensities = null;
writer.WriteLine("ScanNumber, RT, Mass, Intensity");
while (startNum <= endNum)
{
double rt = plus.RetentionTimeFromScanNumber(startNum);
IScanFilter scanFilter = plus.GetFilterForScanNumber(startNum);
if (scanFilter.MSOrder == MSOrderType.Ms)
{
Scan scan = Scan.FromFile(plus, startNum);
IScanEvent scanEvent = plus.GetScanEventForScanNumber(startNum);
if (scan.HasCentroidStream && (scanEvent.ScanData == ScanDataType.Centroid || scanEvent.ScanData == ScanDataType.Profile))
{
var centroidStream = plus.GetCentroidStream(startNum, false);
if (scan.CentroidScan.Length > 0)
{
masses = centroidStream.Masses;
intensities = centroidStream.Intensities;
}
}
else
{
// Get the scan statistics from the RAW file for this scan number
var scanStatistics = plus.GetScanStatsForScanNumber(startNum);
// Get the segmented (low res and profile) scan data
var segmentedScan = plus.GetSegmentedScanFromScanNumber(startNum, scanStatistics);
if (segmentedScan.Positions.Length > 0)
{
masses = segmentedScan.Positions;
intensities = segmentedScan.Intensities;
}
}
for(int i = 0; i < masses.Length; ++ i)
{
masses[i] = Double.Parse(masses[i].ToString("n4"));
}
int front = 0;
int rear = masses.Length - 1;
int mid = front + ((rear - front) >> 1);
bool findVal = false;
while(front <= rear)
{
if (Double.Equals(masses[mid],valMS))
{
findVal = true;
break;
}
else if(masses[mid] < valMS)
{
front = mid + 1;
}
else
{
rear = mid - 1;
}
mid = front + ((rear - front) >> 1);
}
if(findVal && intensities[mid] >= recVal)
{
writer.WriteLine("{0},{1},{2},{3}",startNum.ToString(), rt.ToString(), masses[mid].ToString(), intensities[mid].ToString());
}
}
writer.Flush();
startNum += 1;
}
writer.Close();
}
}
}
//Console.ReadKey();
}
public static void getentityData(string resFilePath, string rawFile, string headerInfo, string paraIndex)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(rawFile);
plus.SelectInstrument(Device.MS, 1);
ArrayList indexOfpara = new ArrayList();
string[] selectIndex = paraIndex.Split(',');
foreach (string ele in selectIndex)
{
int index = Int32.Parse(ele);
indexOfpara.Add(index);
}
//string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".csv";
FileStream stream = new FileStream(resFilePath, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
headerInfo = "RT," + headerInfo;
headerInfo = "#," + headerInfo;
writer.WriteLine(headerInfo);
int offset = 0;
int maxoffset = plus.GetStatusLogEntriesCount();
while (offset < maxoffset)
{
string temp = "";
IStatusLogEntry statusLogEntry = plus.GetStatusLogEntry(offset);
temp += offset.ToString() + ",";
temp += statusLogEntry.Time.ToString() + ",";
foreach (int ele in indexOfpara)
{
temp += Convert.ToString(statusLogEntry.Values[ele]) + ",";
}
writer.WriteLine(temp.Substring(0, temp.Length - 1));
offset += 1;
}
writer.Close();
}
public static void showheaderInfo(string filePath)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
HeaderItem[] statuslogheaderinformation = plus.GetStatusLogHeaderInformation();
int index = 0;
Console.OutputEncoding = Encoding.UTF8;
while (index < statuslogheaderinformation.Length)
{
Console.WriteLine(statuslogheaderinformation[index].Label);
//headerInfo[index] = statuslogheaderinformation[index].Label;
//writer.WriteLine(statuslogheaderinformation[index].Label);
index += 1;
}
//writer.Close();
//while (true)
//{
//if (index >= statuslogheaderinformation.Length)
//{
// Console.WriteLine(plus.RunHeaderEx.FirstSpectrum.ToString());
// Console.WriteLine(plus.RunHeaderEx.LastSpectrum.ToString());
// Console.WriteLine(plus.RunHeaderEx.StartTime.ToString("F2"));
// Console.WriteLine(plus.RunHeaderEx.EndTime.ToString("F2"));
// Console.WriteLine(plus.RunHeaderEx.LowMass.ToString());
// Console.WriteLine(plus.RunHeaderEx.HighMass.ToString());
// break;
//}
// Console.WriteLine(statuslogheaderinformation[index].Label);
// writer.WriteLine(statuslogheaderinformation[index].Label);
// index++;
//}
//writer.Close();
}
public static void getTuneInfo(string filePath)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
plus.SelectInstrument(Device.MS, 1);
string fileName = DateTime.Now.ToLocalTime().ToString().Replace("/", "").Replace(":", "").Replace(" ", "_") + ".txt";
FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
writer.WriteLine("*********************InstrumentMethod(0)***************************");
writer.WriteLine(plus.GetInstrumentMethod(0));
writer.WriteLine("*********************InstrumentMethod(1)****************************");
writer.WriteLine(plus.GetInstrumentMethod(1));
HeaderItem[] tuneDataHeaderInfo = plus.GetTuneDataHeaderInformation();
writer.WriteLine("*********************Tune DATA ****************************");
int tuneCnt = plus.GetTuneDataCount();
for (int i = 0; i < tuneDataHeaderInfo.Length; ++i)
{
writer.WriteLine(tuneDataHeaderInfo[i].Label);
}
writer.Close();
}
public static void getMSdataFromScanNum(int startNum, int endNum, string filePath, double lowMS = 0.00, double highMS = 0.00)
{
IRawDataPlus plus = RawFileReaderAdapter.FileFactory(filePath);
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);
}
/// <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;
}
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();
}
public static void DoQc(QcParameters qcParameters)
{
QcDataCollection qcDataCollection;
string dataDirectory = qcParameters.RawFileDirectory;
string qcDirectory = qcParameters.QcDirectory;
string qcSearchDataDirecotry = qcParameters.QcSearchDataDirectory;
SearchParameters searchParameters = qcParameters.searchParameters;
// our qc file
string qcFile = Path.Combine(qcDirectory, "QC.xml");
// see if the file exists
if (File.Exists(qcFile))
{
// if so, open it
try
{
qcDataCollection = XmlSerialization.ReadFromXmlFile <QcDataCollection>(qcFile);
Log.Information("QC data file loaded successfully");
}
catch (Exception e)
{
Log.Error(e, "Failed while loading QC data");
throw e;
}
}
else
{
// if not, check if the directory exists
if (!Directory.Exists(qcDirectory))
{
Directory.CreateDirectory(qcDirectory);
}
qcDataCollection = new QcDataCollection(dataDirectory, qcDirectory);
Log.Information("Appears to be a new QC directory. New QC data collection created.");
}
// get our list of new raw files. it is every raw file in the directory that is not listed in the qc data
var fileList = Directory.GetFiles(dataDirectory, "*.*", SearchOption.TopDirectoryOnly)
.Where(s => s.EndsWith(".raw", StringComparison.OrdinalIgnoreCase)).ToList();
if (fileList.Count() == 0)
{
Log.Error("No raw files found in {Directory}", dataDirectory);
Console.WriteLine("{0} contains no raw files!", dataDirectory);
Environment.Exit(1);
}
fileList.RemoveAll(s => qcDataCollection.ProcessedRawFiles.Contains(Path.GetFileName(s)));
Log.Information("Raw files in QC queue: {Files}", fileList);
if (fileList.Count() == 0)
{
Log.Information("No new files to QC");
Console.WriteLine("No new files in the directory to QC!");
Environment.Exit(0);
}
Console.WriteLine("{0} file(s) to process", fileList.Count());
foreach (string fileName in fileList)
{
Console.WriteLine("Processing {0}", fileName);
IFileHeader rawHeader;
// try to open the raw file header
try
{
rawHeader = FileHeaderReaderFactory.ReadFile(fileName);;
}
catch (Exception)
{
Log.Information("{File} is not a valid raw file", fileName);
Console.WriteLine("{0} is not a valid raw file, continuing to next file.", fileName);
continue;
}
// is it a real raw file?
if (rawHeader.FileType == FileType.RawFile)
{
Log.Information("{File} is a valid raw file", fileName);
Log.Information("Creation date: {Date}", rawHeader.CreationDate);
Log.Information("File description: {Description}", rawHeader.FileDescription);
}
else
{
Log.Information("{File} is not a valid raw file", fileName);
Console.WriteLine("{0} is not a valid raw file, continuing to next file.", fileName);
continue;
}
// okay, it is probably a real raw file, let's do the QC
// check if the raw file already exists in the QC data with a different name
if (qcDataCollection.QcData.Keys.Contains(rawHeader.CreationDate))
{
Log.Information("A file with the same creation date and time as {File} already exists in the QC data", fileName);
Console.WriteLine("{0} appears to already exist in the QC data with the name {1}. Skipping to next file.",
fileName, qcDataCollection.QcData[rawHeader.CreationDate].RawFile);
continue;
}
using (IRawDataPlus rawFile = RawFileReaderFactory.ReadFile(fileName))
{
rawFile.SelectInstrument(Device.MS, 1);
RawDataCollection rawData = new RawDataCollection(rawFile);
rawData.ExtractAll(rawFile);
/*
* if (idpyPars?.QuantMods != null)
* {
* rawData.quantData.Quantify(rawData, rawFile, )
* }
*/
QcDataContainer newQcData = ProcessQcData(Data: qcDataCollection, rawData: rawData, rawFile: rawFile, qcDirectory: qcDirectory);
if (searchParameters != null)
{
Search.WriteSearchMGF(qcParameters, rawData, rawFile, searchParameters.FixedScans);
Search.RunSearch(qcParameters, rawData, rawFile);
newQcData.ParseSearchResults(rawData, rawFile, qcParameters);
/*
* if (searchParameters.SearchAlgorithm == SearchAlgorithm.XTandem)
* {
* SearchQC.ParseXTandem(newQcData, qcParameters);
* newQcData.IdentipyParameters = String.Format("\"Algorithm: X!Tandem; fmods: {0}; nmod: {1}; kmod: {2}; xmod: {3}; fastaDB: {4}; xtandemDirectory: {5}\"",
* searchParameters.FixedMods, searchParameters.NMod, searchParameters.KMod, searchParameters.XMod, searchParameters.FastaDatabase, searchParameters.XTandemDirectory);
* }
* else
* {
* SearchQC.ParseIdentipy(newQcData, rawData, rawFile, qcParameters);
* newQcData.IdentipyParameters = String.Format("\"Algorithm: IdentiPy; fmods: {0}; nmod: {1}; kmod: {2}; xmod: {3}; fastaDB: {4}; pythonExecutable: {5}; identipyScript: {6}\"",
* searchParameters.FixedMods, searchParameters.NMod, searchParameters.KMod, searchParameters.XMod, searchParameters.FastaDatabase, searchParameters.PythonExecutable, searchParameters.IdentipyScript);
* }
*/
}
qcDataCollection.QcData.Add(rawFile.CreationDate, newQcData);
qcDataCollection.ProcessedRawFiles.Add(Path.GetFileName(rawData.rawFileName));
qcDataCollection.WriteQcToTable();
}
Log.Information("QC finished: {File}", fileName);
}
Log.Information("QC of all files completed");
Console.WriteLine("QC of all files completed!");
try
{
XmlSerialization.WriteToXmlFile <QcDataCollection>(qcFile, qcDataCollection);
Log.Information("QC file saved successfully");
Console.WriteLine("QC file saved successfully");
}
catch (Exception e)
{
Log.Error(e, "Failed during serialization of QC data");
throw e;
}
}
/// <summary>
/// Open the given file and import scans into the reader.
/// </summary>
/// <returns></returns>
public System.Collections.IEnumerator GetEnumerator()
{
rawFile.SelectInstrument(ThermoBiz.Device.MS, 1);
// Get the first and last scan from the RAW file
int FirstScan = rawFile.RunHeaderEx.FirstSpectrum;
int LastScan = rawFile.RunHeaderEx.LastSpectrum;
for (int iScanNumber = FirstScan; iScanNumber <= LastScan; iScanNumber++)
{
ThermoBiz.Scan thermoScan = ThermoBiz.Scan.FromFile(rawFile, iScanNumber);
IScanFilter scanFilter = rawFile.GetFilterForScanNumber(iScanNumber);
IScanEvent scanEvent = rawFile.GetScanEventForScanNumber(iScanNumber);
if ((int)scanFilter.MSOrder == 1)
{
LastMS1 = iScanNumber;
}
Data.Scan scan = new Data.Scan()
{
ScanNumber = iScanNumber,
ScanEvent = (iScanNumber - LastMS1) + 1,
BasePeakIntensity = thermoScan.ScanStatistics.BasePeakIntensity,
BasePeakMz = thermoScan.ScanStatistics.BasePeakMass,
TotalIonCurrent = thermoScan.ScanStatistics.TIC,
LowestMz = thermoScan.ScanStatistics.LowMass,
HighestMz = thermoScan.ScanStatistics.HighMass,
StartMz = scanFilter.GetMassRange(0).Low,
EndMz = scanFilter.GetMassRange(0).High,
ScanType = ReadScanType(scanFilter.ToString()),
MsOrder = (int)scanFilter.MSOrder,
Polarity = (scanFilter.Polarity == PolarityType.Positive) ? Data.Polarity.Positive : Data.Polarity.Negative,
FilterLine = scanFilter.ToString(),
DetectorType = readDetectorType(scanFilter.MassAnalyzer),
RetentionTime = rawFile.RetentionTimeFromScanNumber(iScanNumber)
};
if (scan.MsOrder > 1)
{
// Get the current scan's activation method while ignoring upstream activation
scan.PrecursorActivationMethod = ConvertActivationType(scanFilter.GetActivation(scan.MsOrder - 2));
// handle dependent scans and not SPS (processed below)
scan.Precursors.Clear();
for (int i = 0; i < scanEvent.MassCount; ++i)
{
var reaction = scanEvent.GetReaction(i);
scan.CollisionEnergy = reaction.CollisionEnergy;
var precursor = new Data.Precursor
{
IsolationWidth = reaction.IsolationWidth,
IsolationMz = reaction.PrecursorMass,
Mz = reaction.PrecursorMass,
OriginalMz = reaction.PrecursorMass
};
scan.Precursors.Add(precursor);
}
}
ThermoBiz.RunHeader runHeader = rawFile.RunHeader;
ThermoBiz.LogEntry trailer = rawFile.GetTrailerExtraInformation(iScanNumber);
for (int i = 0; i < trailer.Length; i++)
{
var value = trailer.Values[i];
if (value == null)
{
continue;
}
switch (trailer.Labels[i])
{
case "Access ID":
int access_id = Convert.ToInt32(value);
if (access_id > 0)
{
scan.PrecursorMasterScanNumber = access_id;
}
break;
case "Scan Description:":
scan.Description = value.Trim();
break;
case "Ion Injection Time (ms):":
scan.IonInjectionTime = double.Parse(value);
break;
case "Elapsed Scan Time (sec):":
scan.ElapsedScanTime = double.Parse(value);
break;
case "Charge State:":
int charge = int.Parse(value);
foreach (var precursor in scan.Precursors)
{
precursor.Charge = charge;
precursor.OriginalCharge = precursor.Charge;
}
break;
case "Master Scan Number:":
scan.PrecursorMasterScanNumber = int.Parse(value);
break;
case "Master Index:":
scan.MasterIndex = int.Parse(value);
break;
case "Monoisotopic M/Z:":
if (Options.RawMonoMz && scan.Precursors.Count > 0)
{
double mz = double.Parse(value);
if (mz > 0)
{
scan.Precursors[0].Mz = mz;
}
}
break;
case "FAIMS CV:":
scan.FaimsCV = (int)double.Parse(value);
break;
case "FAIMS Voltage On:":
scan.FaimsState = (value == "No") ? Data.TriState.Off : Data.TriState.On;
break;
case "SPS Masses:":
string[] spsIonStringArray = value.TrimEnd(',').Split(',');
if (!string.IsNullOrWhiteSpace(spsIonStringArray[0]) && spsIonStringArray.Length > 0)
{
scan.Precursors.Clear();
for (int spsIndex = 0; spsIndex < spsIonStringArray.Length; spsIndex++)
{
if (double.TryParse(spsIonStringArray[spsIndex], out double spsIon))
{
scan.Precursors.Add(new Data.Precursor(spsIon, 0, 1));
}
}
}
break;
}
}
if (scan.PrecursorMasterScanNumber <= 0 && scan.MsOrder > 1)
{
// Try again to set the precursor scan.
SetPrecursorScanNumber(scan);
}
if (scan.MsOrder > 1 && scan.PrecursorMasterScanNumber > rawFile.RunHeader.FirstSpectrum && scan.PrecursorMasterScanNumber < rawFile.RunHeader.LastSpectrum)
{
// Fill precursor information
var parentScan = ThermoBiz.Scan.FromFile(rawFile, scan.PrecursorMasterScanNumber);
if (parentScan != null)
{
foreach (var precursor in scan.Precursors)
{
precursor.Intensity = GetMaxIntensity(parentScan, precursor.IsolationMz, precursor.IsolationWidth);
}
}
}
if (thermoScan.HasCentroidStream)
{
// High res data
CentroidsFromArrays(scan, thermoScan.CentroidScan.Masses, thermoScan.CentroidScan.Intensities, thermoScan.CentroidScan.Baselines, thermoScan.CentroidScan.Noises);
}
else
{
// Low res data
CentroidsFromArrays(scan, thermoScan.PreferredMasses, thermoScan.PreferredIntensities);
}
if (scan.PeakCount > 0)
{
scan.LowestMz = scan.Centroids[0].Mz;
scan.HighestMz = scan.Centroids[scan.PeakCount - 1].Mz;
}
yield return(scan);
}
}
