/// <summary>
/// This function is used to determine one or more overall quality scores
/// </summary>
/// <param name="objXcaliburAccessor"></param>
/// <param name="datasetFileInfo"></param>
/// <remarks></remarks>
private void ComputeQualityScores(XRawFileIO objXcaliburAccessor, clsDatasetFileInfo datasetFileInfo)
{
float sngOverallScore;
double dblOverallAvgIntensitySum = 0;
var intOverallAvgCount = 0;
if (mLCMS2DPlot.ScanCountCached > 0)
{
// Obtain the overall average intensity value using the data cached in mLCMS2DPlot
// This avoids having to reload all of the data using objXcaliburAccessor
const int intMSLevelFilter = 1;
sngOverallScore = mLCMS2DPlot.ComputeAverageIntensityAllScans(intMSLevelFilter);
}
else
{
var intScanCount = objXcaliburAccessor.GetNumScans();
GetStartAndEndScans(intScanCount, out var intScanStart, out var intScanEnd);
for (var intScanNumber = intScanStart; intScanNumber <= intScanEnd; intScanNumber++)
{
// This function returns the number of points in dblMassIntensityPairs()
var intReturnCode = objXcaliburAccessor.GetScanData2D(intScanNumber, out var dblMassIntensityPairs);
if (intReturnCode <= 0)
{
continue;
}
if ((dblMassIntensityPairs == null) || dblMassIntensityPairs.GetLength(1) <= 0)
{
continue;
}
// Keep track of the quality scores and then store one or more overall quality scores in datasetFileInfo.OverallQualityScore
// For now, this just computes the average intensity for each scan and then computes and overall average intensity value
double dblIntensitySum = 0;
for (var intIonIndex = 0; intIonIndex <= dblMassIntensityPairs.GetUpperBound(1); intIonIndex++)
{
dblIntensitySum += dblMassIntensityPairs[1, intIonIndex];
}
dblOverallAvgIntensitySum += dblIntensitySum / dblMassIntensityPairs.GetLength(1);
intOverallAvgCount += 1;
}
if (intOverallAvgCount > 0)
{
sngOverallScore = (float)(dblOverallAvgIntensitySum / intOverallAvgCount);
}
else
{
sngOverallScore = 0;
}
}
datasetFileInfo.OverallQualityScore = sngOverallScore;
}
/// <summary>
/// This function is used to determine one or more overall quality scores
/// </summary>
/// <param name="xcaliburAccessor"></param>
/// <param name="datasetFileInfo"></param>
/// <remarks></remarks>
private void ComputeQualityScores(XRawFileIO xcaliburAccessor, DatasetFileInfo datasetFileInfo)
{
float overallScore;
double overallAvgIntensitySum = 0;
var overallAvgCount = 0;
if (mLCMS2DPlot.ScanCountCached > 0)
{
// Obtain the overall average intensity value using the data cached in mLCMS2DPlot
// This avoids having to reload all of the data using xcaliburAccessor
const int msLevelFilter = 1;
overallScore = mLCMS2DPlot.ComputeAverageIntensityAllScans(msLevelFilter);
}
else
{
var scanCount = xcaliburAccessor.GetNumScans();
GetStartAndEndScans(scanCount, out var scanStart, out var scanEnd);
for (var scanNumber = scanStart; scanNumber <= scanEnd; scanNumber++)
{
// This function returns the number of points in massIntensityPairs()
var returnCode = xcaliburAccessor.GetScanData2D(scanNumber, out var massIntensityPairs);
if (returnCode <= 0)
{
continue;
}
if (massIntensityPairs == null || massIntensityPairs.GetLength(1) <= 0)
{
continue;
}
// Keep track of the quality scores and then store one or more overall quality scores in datasetFileInfo.OverallQualityScore
// For now, this just computes the average intensity for each scan and then computes and overall average intensity value
double intensitySum = 0;
for (var ionIndex = 0; ionIndex <= massIntensityPairs.GetUpperBound(1); ionIndex++)
{
intensitySum += massIntensityPairs[1, ionIndex];
}
overallAvgIntensitySum += intensitySum / massIntensityPairs.GetLength(1);
overallAvgCount += 1;
}
if (overallAvgCount > 0)
{
overallScore = (float)(overallAvgIntensitySum / overallAvgCount);
}
else
{
overallScore = 0;
}
}
datasetFileInfo.OverallQualityScore = overallScore;
}
public List <ScanMetadata> ReadScanMetadata()
{
var data = new List <ScanMetadata>();
var numScans = rawFile.GetNumScans();
data.Capacity = numScans + 5;
for (var i = 1; i <= numScans; i++)
{
var infoGood = rawFile.GetScanInfo(i, out clsScanInfo info);
if (!infoGood)
{
continue;
}
var ionInjectionTime = double.Parse(info.ScanEvents.FirstOrDefault(x => x.Key.StartsWith("Ion Injection Time", StringComparison.OrdinalIgnoreCase)).Value ?? "0");
var scan = new ScanMetadata
{
ScanNumber = i,
RetentionTime = info.RetentionTime,
TIC = info.TotalIonCurrent,
BPI = info.BasePeakIntensity,
MSLevel = info.MSLevel,
IonInjectionTime = ionInjectionTime
};
data.Add(scan);
}
return(data);
}
protected bool UpdateDatasetFileStats(
FileInfo rawFileInfo,
int datasetID,
XRawFileIO xcaliburAccessor)
{
// Read the file info from the file system
var success = UpdateDatasetFileStats(rawFileInfo, datasetID);
if (!success)
{
return(false);
}
// Read the file info using the Xcalibur Accessor
try
{
mDatasetFileInfo.AcqTimeStart = xcaliburAccessor.FileInfo.CreationDate;
}
catch (Exception ex)
{
// Read error
return(false);
}
try
{
// Look up the end scan time then compute .AcqTimeEnd
var scanEnd = xcaliburAccessor.ScanEnd;
xcaliburAccessor.GetScanInfo(scanEnd, out ThermoRawFileReader.clsScanInfo scanInfo);
mDatasetFileInfo.AcqTimeEnd = mDatasetFileInfo.AcqTimeStart.AddMinutes(scanInfo.RetentionTime);
mDatasetFileInfo.ScanCount = xcaliburAccessor.GetNumScans();
}
catch (Exception ex)
{
// Error; use default values
mDatasetFileInfo.AcqTimeEnd = mDatasetFileInfo.AcqTimeStart;
mDatasetFileInfo.ScanCount = 0;
}
return(true);
}
private int ReadNumSpectra()
{
var numSpectra = _msfileReader.GetNumScans();
return(numSpectra);
}
private int ValidateScanNumber(int scan, XRawFileIO rawReader)
{
var totalSpectra = rawReader.GetNumScans();
if (scan > totalSpectra)
{
throw new ScanOutOfRangeException("The requested scan is out of range.");
}
return scan;
}
private bool ProcessFile(string filePath, string outputDirectoryPath)
{
try
{
OnStatusEvent(string.Format("Processing {0}", filePath));
// Compute the SHA-1 hash of the .Raw file
var fileSha1 = HashRawFile(filePath);
// Disable loading the method
// Method loading doesn't work on Linux and this program doesn't need that information
var readerOptions = new ThermoReaderOptions
{
LoadMSMethodInfo = false
};
// Open up the raw file connection
var reader = new XRawFileIO(filePath, readerOptions);
// Get all unique CV values from scans
var cvValues = GetUniqueCvValues(reader);
var totalScanCount = reader.GetNumScans();
var scansProcessed = 0;
var lastProgress = DateTime.UtcNow;
// Reset tracking variables
ByteTracking.Reset(true);
// Now work for each unique CV value (# files we're going to need to split into)
// get all scans that have the CV that we're currently targeting
foreach (var cvValue in cvValues)
{
var baseName = Path.GetFileNameWithoutExtension(filePath);
var mzXmlPath = Path.Combine(outputDirectoryPath, baseName + "_" + cvValue + ".mzXML");
OnDebugEvent(string.Format("Creating file {0}", mzXmlPath));
var targetScans = FindAllTargetScans(cvValue, reader);
var parentScanToMS2Map = new Dictionary <int, List <int> >();
using (var writer = new StreamWriter(new FileStream(mzXmlPath, FileMode.Create, FileAccess.Write, FileShare.Read)))
{
WriteHeader(writer, filePath, reader, fileSha1, targetScans);
Ms1Scan currentMS1Scan = null;
// Write out our target scans
foreach (var scanNumber in targetScans)
{
if (DateTime.UtcNow.Subtract(lastProgress).TotalSeconds >= 3)
{
var percentComplete = scansProcessed / (double)totalScanCount * 100;
OnDebugEvent(string.Format("... processing: {0:F0}% complete", percentComplete));
lastProgress = DateTime.UtcNow;
}
var scan = new MsScan(scanNumber, reader);
if (scan.MsLevel == 1)
{
parentScanToMS2Map.Add(scan.ScanNumber, new List <int>());
if (currentMS1Scan == null)
{
// Start condition
currentMS1Scan = Ms1Scan.Create(scan);
}
else
{
// Write currentMS1Scan to file
var outString = currentMS1Scan.ToXML(this);
writer.WriteLine(outString);
currentMS1Scan = Ms1Scan.Create(scan);
}
}
else if (scan.MsLevel == 2)
{
if (currentMS1Scan != null)
{
parentScanToMS2Map[currentMS1Scan.ScanNumber].Add(scan.ScanNumber);
}
var ms2Scan = Ms2Scan.Create(scan);
ms2Scan.AddMs2ScanParameters(reader);
currentMS1Scan?.AddMs2Scan(ms2Scan);
}
scansProcessed++;
}
if (currentMS1Scan != null)
{
// Once we're out, we need to write out our last currentMS1Scan
writer.WriteLine(currentMS1Scan.ToXML(this));
}
// Finish off msRun
writer.WriteLine(" </msRun>");
writer.WriteLine(" <index name=\"scan\">");
// Add special entry to our indexOffset list for where the offsets start
var index = new Index(0, ByteTracking.ByteDepth + ByteTracking.Encoder.GetByteCount(" </msRun>") + 3);
ByteTracking.ScanOffsets.Add(index);
// Write all index offsets
for (var i = 0; i < ByteTracking.ScanOffsets.Count - 1; i++)
{
var offset = ByteTracking.ScanOffsets[i];
writer.WriteLine(" <offset id=\"" + offset.ScanNumber + "\">" + offset.ByteDepth + "</offset>");
}
writer.WriteLine(" </index>");
writer.WriteLine(" <indexOffset>" + ByteTracking.ScanOffsets.Last().ByteDepth + "</indexOffset>");
writer.Write(" <sha1>");
}
// Compute the SHA-1 hash of the file up to this point
var mzXmlHash = HashMzXML(mzXmlPath);
// Append the hash
using (var writer = new StreamWriter(mzXmlPath, true))
{
writer.Write(mzXmlHash);
writer.WriteLine("</sha1>");
writer.WriteLine("</mzXML>");
}
// Reset tracking variables, but do not restart scan numbering
ByteTracking.Reset(false);
}
OnDebugEvent(string.Format("... processing: {0:F0}% complete", 100));
return(true);
}
catch (Exception ex)
{
OnErrorEvent("Error in ProcessFile", ex);
return(false);
}
}
private static void TestGetAllScanEvents(string rawFilePath)
{
try
{
var rawFile = ResolveDataFile(rawFilePath);
if (rawFile == null)
{
return;
}
Console.WriteLine();
Console.WriteLine("Opening " + rawFile.FullName);
// Keys in this dictionary are event names
// Values are dictionaries tracking all of the values for each event (key is value, value is occurrence of that value)
var scanEventStats = new Dictionary <string, Dictionary <string, int> >();
var lastProgress = DateTime.UtcNow;
var scansRead = 0;
var scansReadSinceLastProgress = 0;
var options = new ThermoReaderOptions
{
LoadMSMethodInfo = mLoadMethods
};
using (var reader = new XRawFileIO(rawFile.FullName, options))
{
var scanCount = reader.GetNumScans();
for (var scanNum = 1; scanNum <= scanCount; scanNum++)
{
var success = reader.GetScanInfo(scanNum, out clsScanInfo scanInfo);
if (!success)
{
ShowWarning("GetScanInfo returned false for scan " + scanNum);
continue;
}
foreach (var eventItem in scanInfo.ScanEvents)
{
if (!scanEventStats.TryGetValue(eventItem.Key, out var valueStats))
{
valueStats = new Dictionary <string, int>();
scanEventStats.Add(eventItem.Key, valueStats);
}
if (valueStats.TryGetValue(eventItem.Value, out var valueCount))
{
valueStats[eventItem.Value] = valueCount + 1;
}
else
{
valueStats.Add(eventItem.Value, 1);
}
}
scansRead++;
scansReadSinceLastProgress++;
var elapsedSeconds = DateTime.UtcNow.Subtract(lastProgress).TotalSeconds;
if (!(elapsedSeconds > 3) || scansRead % 100 != 0)
{
continue;
}
lastProgress = DateTime.UtcNow;
var percentComplete = scansRead / (double)scanCount * 100;
var scansPerSecond = scansReadSinceLastProgress / elapsedSeconds;
Console.WriteLine("Reading scan events; {0:F1}% complete ({1} / {2} scans); {3:F0} scans/second",
percentComplete, scansRead, scanCount, scansPerSecond);
scansReadSinceLastProgress = 0;
}
}
Console.WriteLine();
Console.WriteLine("{0,-38} {1,-10} {2,-20} {3}", "Event name", "Values", "Most Common Value", "Occurrence count");
foreach (var eventInfo in scanEventStats)
{
var eventName = eventInfo.Key;
var valueCount = eventInfo.Value.Count;
var occurrenceCount = 0;
var mostCommonValue = "";
foreach (var item in eventInfo.Value)
{
if (item.Value <= occurrenceCount)
{
continue;
}
occurrenceCount = item.Value;
mostCommonValue = item.Key;
}
if (string.IsNullOrWhiteSpace(mostCommonValue))
{
Console.WriteLine("{0,-38} {1,-10} {2,-20} {3:N0}", eventName, valueCount, "whitespace", occurrenceCount);
}
else
{
Console.WriteLine("{0,-38} {1,-10} {2,-20} {3:N0}", eventName, valueCount, mostCommonValue, occurrenceCount);
}
}
Console.WriteLine();
}
catch (Exception ex)
{
ShowError("Error in TestGetAllScanEvents: " + ex.Message, ex);
}
}
private static void TestReader(string rawFilePath, bool centroid = false, bool testSumming = false, int scanStart = 0, int scanEnd = 0)
{
try
{
var rawFile = ResolveDataFile(rawFilePath);
if (rawFile == null)
{
return;
}
var options = new ThermoReaderOptions {
LoadMSMethodInfo = mLoadMethods
};
using (var reader = new XRawFileIO(rawFile.FullName, options, mTraceMode))
{
RegisterEvents(reader);
var numScans = reader.GetNumScans();
var collisionEnergyList = string.Empty;
ShowMethod(reader);
var scanStep = 1;
if (scanStart < 1)
{
scanStart = 1;
}
if (scanEnd < 1)
{
scanEnd = numScans;
scanStep = 21;
}
else
{
if (scanEnd < scanStart)
{
scanEnd = scanStart;
}
}
if (scanEnd > numScans)
{
scanEnd = numScans;
}
var msLevelStats = new Dictionary <int, int>();
Console.WriteLine();
Console.WriteLine("Reading data for scans {0} to {1}, step {2}", scanStart, scanEnd, scanStep);
for (var scanNum = scanStart; scanNum <= scanEnd; scanNum += scanStep)
{
if (scanNum > reader.ScanEnd)
{
ConsoleMsgUtils.ShowWarning("Exiting for loop since scan number {0} is greater than the max scan number, {1}", scanNum, reader.ScanEnd);
break;
}
if (mOnlyLoadMSLevelInfo)
{
var msLevel = reader.GetMSLevel(scanNum);
if (msLevelStats.TryGetValue(msLevel, out var msLevelObsCount))
{
msLevelStats[msLevel] = msLevelObsCount + 1;
}
else
{
msLevelStats.Add(msLevel, 1);
}
if (mScanInfoInterval <= 0 || scanNum % mScanInfoInterval == 0)
{
Console.WriteLine("Scan " + scanNum);
}
continue;
}
var success = reader.GetScanInfo(scanNum, out clsScanInfo scanInfo);
if (!success)
{
continue;
}
if (mScanInfoInterval <= 0 || scanNum % mScanInfoInterval == 0)
{
Console.WriteLine("Scan " + scanNum + " at " + scanInfo.RetentionTime.ToString("0.00") + " minutes: " + scanInfo.FilterText);
}
if (mLoadCollisionEnergies)
{
var collisionEnergies = reader.GetCollisionEnergy(scanNum);
if (collisionEnergies.Count == 0)
{
collisionEnergyList = string.Empty;
}
else if (collisionEnergies.Count >= 1)
{
collisionEnergyList = collisionEnergies[0].ToString("0.0");
if (collisionEnergies.Count > 1)
{
for (var index = 1; index <= collisionEnergies.Count - 1; index++)
{
collisionEnergyList += ", " + collisionEnergies[index].ToString("0.0");
}
}
}
if (string.IsNullOrEmpty(collisionEnergyList))
{
Console.WriteLine();
}
else
{
Console.WriteLine("; CE " + collisionEnergyList);
}
}
if (mGetScanEvents)
{
if (scanInfo.TryGetScanEvent("Monoisotopic M/Z:", out var monoMZ))
{
Console.WriteLine("Monoisotopic M/Z: " + monoMZ);
}
if (scanInfo.TryGetScanEvent("Charge State", out var chargeState, true))
{
Console.WriteLine("Charge State: " + chargeState);
}
if (scanInfo.TryGetScanEvent("MS2 Isolation Width", out var isolationWidth, true))
{
Console.WriteLine("MS2 Isolation Width: " + isolationWidth);
}
}
if (!mLoadScanData || (scanNum % 50 != 0 && scanEnd - scanStart > 50))
{
continue;
}
// Get the data for scan scanNum
Console.WriteLine();
Console.WriteLine("Spectrum for scan " + scanNum);
reader.GetScanData(scanNum, out var mzList, out var intensityList, 0, centroid);
var mzDisplayStepSize = 50;
if (centroid)
{
mzDisplayStepSize = 1;
}
for (var i = 0; i <= mzList.Length - 1; i += mzDisplayStepSize)
{
Console.WriteLine(" " + mzList[i].ToString("0.000") + " mz " + intensityList[i].ToString("0"));
}
Console.WriteLine();
const int scansToSum = 15;
if (scanNum + scansToSum < numScans && testSumming)
{
// Get the data for scan scanNum through scanNum + 15
#pragma warning disable 618
reader.GetScanDataSumScans(scanNum, scanNum + scansToSum, out var massIntensityPairs, 0, centroid);
#pragma warning restore 618
Console.WriteLine("Summed spectrum, scans " + scanNum + " through " + (scanNum + scansToSum));
for (var i = 0; i <= massIntensityPairs.GetLength(1) - 1; i += 50)
{
Console.WriteLine(" " + massIntensityPairs[0, i].ToString("0.000") + " mz " +
massIntensityPairs[1, i].ToString("0"));
}
Console.WriteLine();
}
if (!scanInfo.IsFTMS)
{
continue;
}
var dataCount = reader.GetScanLabelData(scanNum, out var ftLabelData);
Console.WriteLine();
Console.WriteLine("{0,12}{1,12}{2,12}{3,12}{4,12}{5,12}", "Mass", "Intensity", "Resolution", "Baseline", "Noise", "Charge");
for (var i = 0; i <= dataCount - 1; i += 50)
{
Console.WriteLine("{0,12:F3}{1,12:0}{2,12:0}{3,12:F1}{4,12:0}{5,12:0}",
ftLabelData[i].Mass,
ftLabelData[i].Intensity,
ftLabelData[i].Resolution,
ftLabelData[i].Baseline,
ftLabelData[i].Noise,
ftLabelData[i].Charge);
}
dataCount = reader.GetScanPrecisionData(scanNum, out var ftPrecisionData);
Console.WriteLine();
Console.WriteLine("{0,12}{1,12}{2,12}{3,12}{4,12}", "Mass", "Intensity", "AccuracyMMU", "AccuracyPPM", "Resolution");
for (var i = 0; i <= dataCount - 1; i += 50)
{
Console.WriteLine("{0,12:F3}{1,12:0}{2,12:F3}{3,12:F3}{4,12:0}",
ftPrecisionData[i].Mass,
ftPrecisionData[i].Intensity, ftPrecisionData[i].AccuracyMMU,
ftPrecisionData[i].AccuracyPPM,
ftPrecisionData[i].Resolution);
}
}
if (mOnlyLoadMSLevelInfo)
{
Console.WriteLine();
Console.WriteLine("{0,-10} {1}", "MSLevel", "Scans");
foreach (var item in msLevelStats)
{
Console.WriteLine("{0, -10} {1}", item.Key, item.Value);
}
}
}
}
catch (Exception ex)
{
ShowError("Error in TestReader: " + ex.Message, ex);
}
}
/// <summary>
/// Process the dataset
/// </summary>
/// <param name="dataFilePath"></param>
/// <param name="datasetFileInfo"></param>
/// <returns>True if success, False if an error or if the file has no scans</returns>
/// <remarks></remarks>
public override bool ProcessDataFile(string dataFilePath, DatasetFileInfo datasetFileInfo)
{
ResetResults();
var dataFilePathLocal = string.Empty;
// Obtain the full path to the file
var rawFile = new FileInfo(dataFilePath);
if (!rawFile.Exists)
{
OnErrorEvent(".Raw file not found: " + dataFilePath);
return(false);
}
// Future, optional: Determine the DatasetID
// Unfortunately, this is not present in metadata.txt
// datasetID = LookupDatasetID(datasetName)
var datasetID = DatasetID;
// Record the file size and Dataset ID
datasetFileInfo.FileSystemCreationTime = rawFile.CreationTime;
datasetFileInfo.FileSystemModificationTime = rawFile.LastWriteTime;
// The acquisition times will get updated below to more accurate values
datasetFileInfo.AcqTimeStart = datasetFileInfo.FileSystemModificationTime;
datasetFileInfo.AcqTimeEnd = datasetFileInfo.FileSystemModificationTime;
datasetFileInfo.DatasetID = datasetID;
datasetFileInfo.DatasetName = GetDatasetNameViaPath(rawFile.Name);
datasetFileInfo.FileExtension = rawFile.Extension;
datasetFileInfo.FileSizeBytes = rawFile.Length;
datasetFileInfo.ScanCount = 0;
mDatasetStatsSummarizer.ClearCachedData();
var deleteLocalFile = false;
var readError = false;
// Note: as of June 2018 this only works if you disable "Prefer 32-bit" when compiling as AnyCPU
// Use XRaw to read the .Raw file
// If reading from a SAMBA-mounted network share, and if the current user has
// Read privileges but not Read&Execute privileges, we will need to copy the file locally
var readerOptions = new ThermoReaderOptions
{
LoadMSMethodInfo = true,
LoadMSTuneInfo = true
};
var xcaliburAccessor = new XRawFileIO(readerOptions);
RegisterEvents(xcaliburAccessor);
// Open a handle to the data file
if (!xcaliburAccessor.OpenRawFile(rawFile.FullName))
{
// File open failed
OnErrorEvent("Call to .OpenRawFile failed for: " + rawFile.FullName);
ErrorCode = iMSFileInfoScanner.eMSFileScannerErrorCodes.ThermoRawFileReaderError;
readError = true;
if (!string.Equals(clsMSFileInfoScanner.GetAppDirectoryPath().Substring(0, 2), rawFile.FullName.Substring(0, 2), StringComparison.InvariantCultureIgnoreCase))
{
if (mCopyFileLocalOnReadError)
{
// Copy the file locally and try again
try
{
dataFilePathLocal = Path.Combine(clsMSFileInfoScanner.GetAppDirectoryPath(), Path.GetFileName(dataFilePath));
if (!string.Equals(dataFilePathLocal, dataFilePath, StringComparison.InvariantCultureIgnoreCase))
{
OnDebugEvent("Copying file " + Path.GetFileName(dataFilePath) + " to the working directory");
File.Copy(dataFilePath, dataFilePathLocal, true);
dataFilePath = string.Copy(dataFilePathLocal);
deleteLocalFile = true;
// Update rawFile then try to re-open
rawFile = new FileInfo(dataFilePath);
if (!xcaliburAccessor.OpenRawFile(rawFile.FullName))
{
// File open failed
OnErrorEvent("Call to .OpenRawFile failed for: " + rawFile.FullName);
ErrorCode = iMSFileInfoScanner.eMSFileScannerErrorCodes.ThermoRawFileReaderError;
readError = true;
}
else
{
readError = false;
}
}
}
catch (Exception)
{
readError = true;
}
}
}
}
if (!readError)
{
// Read the file info
try
{
datasetFileInfo.AcqTimeStart = xcaliburAccessor.FileInfo.CreationDate;
}
catch (Exception)
{
// Read error
readError = true;
}
if (!readError)
{
try
{
datasetFileInfo.ScanCount = xcaliburAccessor.GetNumScans();
if (datasetFileInfo.ScanCount > 0)
{
// Look up the end scan time then compute .AcqTimeEnd
var scanEnd = xcaliburAccessor.FileInfo.ScanEnd;
xcaliburAccessor.GetScanInfo(scanEnd, out clsScanInfo scanInfo);
datasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeStart.AddMinutes(scanInfo.RetentionTime);
}
else
{
datasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeStart;
}
}
catch (Exception)
{
// Error; use default values
datasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeStart;
datasetFileInfo.ScanCount = 0;
}
if (mSaveTICAndBPI || mCreateDatasetInfoFile || mCreateScanStatsFile ||
mSaveLCMS2DPlots || mCheckCentroidingStatus || MS2MzMin > 0)
{
// Load data from each scan
// This is used to create the TIC and BPI plot, the 2D LC/MS plot, and/or to create the Dataset Info File
LoadScanDetails(xcaliburAccessor);
}
if (mComputeOverallQualityScores)
{
// Note that this call will also create the TICs and BPIs
ComputeQualityScores(xcaliburAccessor, datasetFileInfo);
}
if (MS2MzMin > 0 && datasetFileInfo.ScanCount > 0)
{
// Verify that all of the MS2 spectra have m/z values below the required minimum
// Useful for validating that reporter ions can be detected
ValidateMS2MzMin();
}
}
}
mDatasetStatsSummarizer.SampleInfo.SampleName = xcaliburAccessor.FileInfo.SampleName;
mDatasetStatsSummarizer.SampleInfo.Comment1 = xcaliburAccessor.FileInfo.Comment1;
mDatasetStatsSummarizer.SampleInfo.Comment2 = xcaliburAccessor.FileInfo.Comment2;
// Add the devices
var deviceFilterList = new SortedSet <Device> {
Device.MS,
Device.MSAnalog
};
// First add the MS devices
AddThermoDevices(xcaliburAccessor, datasetFileInfo, deviceFilterList, new SortedSet <Device>());
// Now add any non-mass spec devices
AddThermoDevices(xcaliburAccessor, datasetFileInfo, new SortedSet <Device>(), deviceFilterList);
if (mSaveTICAndBPI && datasetFileInfo.DeviceList.Count > 0)
{
mInstrumentSpecificPlots.Clear();
foreach (var device in datasetFileInfo.DeviceList)
{
if (device.DeviceType == Device.MS || device.DeviceType == Device.MSAnalog)
{
continue;
}
var chromatogramData = xcaliburAccessor.GetChromatogramData(device.DeviceType, device.DeviceNumber);
if (chromatogramData.Count == 0)
{
continue;
}
var devicePlot = AddInstrumentSpecificPlot(device.DeviceDescription);
devicePlot.TICXAxisLabel = string.IsNullOrWhiteSpace(device.AxisLabelX) ? "Scan number" : device.AxisLabelX;
devicePlot.TICYAxisLabel = device.YAxisLabelWithUnits;
devicePlot.TICYAxisExponentialNotation = false;
devicePlot.DeviceType = device.DeviceType;
devicePlot.TICPlotAbbrev = string.Format("{0}{1}", device.DeviceType.ToString(), device.DeviceNumber);
devicePlot.TICAutoMinMaxY = true;
devicePlot.RemoveZeroesFromEnds = false;
float acqLengthMinutes;
if (datasetFileInfo.AcqTimeEnd > datasetFileInfo.AcqTimeStart)
{
acqLengthMinutes = (float)datasetFileInfo.AcqTimeEnd.Subtract(datasetFileInfo.AcqTimeStart).TotalMinutes;
}
else
{
acqLengthMinutes = chromatogramData.Count;
}
var dataCount = chromatogramData.Count;
foreach (var dataPoint in chromatogramData)
{
var scanNumber = dataPoint.Key;
float scanTimeMinutes;
if (acqLengthMinutes > 0)
{
scanTimeMinutes = scanNumber / (float)dataCount * acqLengthMinutes;
}
else
{
scanTimeMinutes = scanNumber;
}
devicePlot.AddDataTICOnly(scanNumber, 1, scanTimeMinutes, dataPoint.Value);
}
}
}
if (!string.IsNullOrEmpty(xcaliburAccessor.FileInfo.SampleComment))
{
if (string.IsNullOrEmpty(mDatasetStatsSummarizer.SampleInfo.Comment1))
{
mDatasetStatsSummarizer.SampleInfo.Comment1 = xcaliburAccessor.FileInfo.SampleComment;
}
else
{
if (string.IsNullOrEmpty(mDatasetStatsSummarizer.SampleInfo.Comment2))
{
mDatasetStatsSummarizer.SampleInfo.Comment2 = xcaliburAccessor.FileInfo.SampleComment;
}
else
{
// Append the sample comment to comment 2
mDatasetStatsSummarizer.SampleInfo.Comment2 += "; " + xcaliburAccessor.FileInfo.SampleComment;
}
}
}
// Close the handle to the data file
xcaliburAccessor.CloseRawFile();
// Read the file info from the file system
// (much of this is already in datasetFileInfo, but we'll call UpdateDatasetFileStats() anyway to make sure all of the necessary steps are taken)
// This will also compute the SHA-1 hash of the .Raw file and add it to mDatasetStatsSummarizer.DatasetFileInfo
UpdateDatasetFileStats(rawFile, datasetID);
// Copy over the updated file time info from datasetFileInfo to mDatasetStatsSummarizer.DatasetFileInfo
UpdateDatasetStatsSummarizerUsingDatasetFileInfo(datasetFileInfo);
// Delete the local copy of the data file
if (deleteLocalFile)
{
try
{
File.Delete(dataFilePathLocal);
}
catch (Exception)
{
// Deletion failed
OnErrorEvent("Deletion failed for: " + Path.GetFileName(dataFilePathLocal));
}
}
PostProcessTasks();
return(!readError);
}
private void LoadScanDetails(XRawFileIO xcaliburAccessor)
{
OnStatusEvent(" Loading scan details");
if (mSaveTICAndBPI)
{
// Initialize the TIC and BPI arrays
InitializeTICAndBPI();
}
if (mSaveLCMS2DPlots)
{
InitializeLCMS2DPlot();
}
var lastProgressTime = DateTime.UtcNow;
// Note that this starts at 2 seconds, but is extended after each progress message is shown (maxing out at 30 seconds)
var progressThresholdSeconds = 2;
var scanCount = xcaliburAccessor.GetNumScans();
GetStartAndEndScans(scanCount, out var scanStart, out var scanEnd);
var scansProcessed = 0;
var totalScansToProcess = scanEnd - scanStart + 1;
for (var scanNumber = scanStart; scanNumber <= scanEnd; scanNumber++)
{
clsScanInfo scanInfo;
try
{
var success = xcaliburAccessor.GetScanInfo(scanNumber, out scanInfo);
if (success)
{
if (mSaveTICAndBPI)
{
mTICAndBPIPlot.AddData(
scanNumber,
scanInfo.MSLevel,
(float)scanInfo.RetentionTime,
scanInfo.BasePeakIntensity,
scanInfo.TotalIonCurrent);
}
var scanStatsEntry = new ScanStatsEntry
{
ScanNumber = scanNumber,
ScanType = scanInfo.MSLevel,
ScanTypeName = XRawFileIO.GetScanTypeNameFromThermoScanFilterText(scanInfo.FilterText),
ScanFilterText = XRawFileIO.MakeGenericThermoScanFilter(scanInfo.FilterText),
ElutionTime = scanInfo.RetentionTime.ToString("0.0###"),
TotalIonIntensity = StringUtilities.ValueToString(scanInfo.TotalIonCurrent, 5),
BasePeakIntensity = StringUtilities.ValueToString(scanInfo.BasePeakIntensity, 5),
BasePeakMZ = scanInfo.BasePeakMZ.ToString("0.0###"),
BasePeakSignalToNoiseRatio = "0",
IonCount = scanInfo.NumPeaks,
IonCountRaw = scanInfo.NumPeaks,
MzMin = scanInfo.LowMass,
MzMax = scanInfo.HighMass
};
// Store the ScanEvent values in .ExtendedScanInfo
StoreExtendedScanInfo(scanStatsEntry.ExtendedScanInfo, scanInfo.ScanEvents);
// Store the collision mode and the scan filter text
scanStatsEntry.ExtendedScanInfo.CollisionMode = scanInfo.CollisionMode;
scanStatsEntry.ExtendedScanInfo.ScanFilterText = scanInfo.FilterText;
mDatasetStatsSummarizer.AddDatasetScan(scanStatsEntry);
}
}
catch (Exception ex)
{
OnErrorEvent("Error loading header info for scan " + scanNumber + ": " + ex.Message);
continue;
}
try
{
if (mSaveLCMS2DPlots || mCheckCentroidingStatus)
{
// Also need to load the raw data
// Load the ions for this scan
var ionCount = xcaliburAccessor.GetScanData2D(scanNumber, out var massIntensityPairs);
if (ionCount > 0)
{
if (mSaveLCMS2DPlots)
{
mLCMS2DPlot.AddScan2D(scanNumber, scanInfo.MSLevel, (float)scanInfo.RetentionTime, ionCount, massIntensityPairs);
}
if (mCheckCentroidingStatus)
{
var mzCount = massIntensityPairs.GetLength(1);
var mzList = new List <double>(mzCount);
for (var i = 0; i <= mzCount - 1; i++)
{
mzList.Add(massIntensityPairs[0, i]);
}
var centroidingStatus = GetCentroidStatus(scanNumber, scanInfo);
mDatasetStatsSummarizer.ClassifySpectrum(mzList, scanInfo.MSLevel, centroidingStatus, "Scan " + scanNumber);
}
}
}
}
catch (Exception ex)
{
OnErrorEvent("Error loading m/z and intensity values for scan " + scanNumber + ": " + ex.Message);
}
scansProcessed++;
if (DateTime.UtcNow.Subtract(lastProgressTime).TotalSeconds < progressThresholdSeconds)
{
continue;
}
lastProgressTime = DateTime.UtcNow;
if (progressThresholdSeconds < 30)
{
progressThresholdSeconds += 2;
}
var percentComplete = scansProcessed / (float)totalScansToProcess * 100;
OnProgressUpdate(string.Format("Spectra processed: {0:N0}", scansProcessed), percentComplete);
}
Console.WriteLine();
}
/// <summary>
/// Process the dataset
/// </summary>
/// <param name="strDataFilePath"></param>
/// <param name="datasetFileInfo"></param>
/// <returns>True if success, False if an error</returns>
/// <remarks></remarks>
public override bool ProcessDataFile(string strDataFilePath, clsDatasetFileInfo datasetFileInfo)
{
var strDataFilePathLocal = string.Empty;
// Obtain the full path to the file
var fiRawFile = new FileInfo(strDataFilePath);
if (!fiRawFile.Exists)
{
OnErrorEvent(".Raw file not found: " + strDataFilePath);
return(false);
}
// Future, optional: Determine the DatasetID
// Unfortunately, this is not present in metadata.txt
// intDatasetID = LookupDatasetID(strDatasetName)
var intDatasetID = DatasetID;
// Record the file size and Dataset ID
datasetFileInfo.FileSystemCreationTime = fiRawFile.CreationTime;
datasetFileInfo.FileSystemModificationTime = fiRawFile.LastWriteTime;
// The acquisition times will get updated below to more accurate values
datasetFileInfo.AcqTimeStart = datasetFileInfo.FileSystemModificationTime;
datasetFileInfo.AcqTimeEnd = datasetFileInfo.FileSystemModificationTime;
datasetFileInfo.DatasetID = intDatasetID;
datasetFileInfo.DatasetName = GetDatasetNameViaPath(fiRawFile.Name);
datasetFileInfo.FileExtension = fiRawFile.Extension;
datasetFileInfo.FileSizeBytes = fiRawFile.Length;
datasetFileInfo.ScanCount = 0;
mDatasetStatsSummarizer.ClearCachedData();
var blnDeleteLocalFile = false;
var blnReadError = false;
// Use Xraw to read the .Raw file
// If reading from a SAMBA-mounted network share, and if the current user has
// Read privileges but not Read&Execute privileges, then we will need to copy the file locally
var xcaliburAccessor = new XRawFileIO();
// Attach event handlers
xcaliburAccessor.ReportError += XcaliburAccessor_ReportError;
xcaliburAccessor.ReportWarning += XcaliburAccessor_ReportWarning;
// Open a handle to the data file
if (!xcaliburAccessor.OpenRawFile(fiRawFile.FullName))
{
// File open failed
OnErrorEvent("Call to .OpenRawFile failed for: " + fiRawFile.FullName);
blnReadError = true;
if (!string.Equals(clsMSFileInfoScanner.GetAppFolderPath().Substring(0, 2), fiRawFile.FullName.Substring(0, 2), StringComparison.InvariantCultureIgnoreCase))
{
if (mCopyFileLocalOnReadError)
{
// Copy the file locally and try again
try
{
strDataFilePathLocal = Path.Combine(clsMSFileInfoScanner.GetAppFolderPath(), Path.GetFileName(strDataFilePath));
if (!string.Equals(strDataFilePathLocal, strDataFilePath, StringComparison.InvariantCultureIgnoreCase))
{
OnDebugEvent("Copying file " + Path.GetFileName(strDataFilePath) + " to the working folder");
File.Copy(strDataFilePath, strDataFilePathLocal, true);
strDataFilePath = string.Copy(strDataFilePathLocal);
blnDeleteLocalFile = true;
// Update fiRawFile then try to re-open
fiRawFile = new FileInfo(strDataFilePath);
if (!xcaliburAccessor.OpenRawFile(fiRawFile.FullName))
{
// File open failed
OnErrorEvent("Call to .OpenRawFile failed for: " + fiRawFile.FullName);
blnReadError = true;
}
else
{
blnReadError = false;
}
}
}
catch (Exception)
{
blnReadError = true;
}
}
}
}
if (!blnReadError)
{
// Read the file info
try
{
datasetFileInfo.AcqTimeStart = xcaliburAccessor.FileInfo.CreationDate;
}
catch (Exception)
{
// Read error
blnReadError = true;
}
if (!blnReadError)
{
try
{
// Look up the end scan time then compute .AcqTimeEnd
var intScanEnd = xcaliburAccessor.FileInfo.ScanEnd;
xcaliburAccessor.GetScanInfo(intScanEnd, out clsScanInfo scanInfo);
datasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeStart.AddMinutes(scanInfo.RetentionTime);
datasetFileInfo.ScanCount = xcaliburAccessor.GetNumScans();
}
catch (Exception)
{
// Error; use default values
datasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeStart;
datasetFileInfo.ScanCount = 0;
}
if (mSaveTICAndBPI || mCreateDatasetInfoFile || mCreateScanStatsFile || mSaveLCMS2DPlots || mCheckCentroidingStatus)
{
// Load data from each scan
// This is used to create the TIC and BPI plot, the 2D LC/MS plot, and/or to create the Dataset Info File
LoadScanDetails(xcaliburAccessor);
}
if (mComputeOverallQualityScores)
{
// Note that this call will also create the TICs and BPIs
ComputeQualityScores(xcaliburAccessor, datasetFileInfo);
}
}
}
mDatasetStatsSummarizer.SampleInfo.SampleName = xcaliburAccessor.FileInfo.SampleName;
mDatasetStatsSummarizer.SampleInfo.Comment1 = xcaliburAccessor.FileInfo.Comment1;
mDatasetStatsSummarizer.SampleInfo.Comment2 = xcaliburAccessor.FileInfo.Comment2;
if (!string.IsNullOrEmpty(xcaliburAccessor.FileInfo.SampleComment))
{
if (string.IsNullOrEmpty(mDatasetStatsSummarizer.SampleInfo.Comment1))
{
mDatasetStatsSummarizer.SampleInfo.Comment1 = xcaliburAccessor.FileInfo.SampleComment;
}
else
{
if (string.IsNullOrEmpty(mDatasetStatsSummarizer.SampleInfo.Comment2))
{
mDatasetStatsSummarizer.SampleInfo.Comment2 = xcaliburAccessor.FileInfo.SampleComment;
}
else
{
// Append the sample comment to comment 2
mDatasetStatsSummarizer.SampleInfo.Comment2 += "; " + xcaliburAccessor.FileInfo.SampleComment;
}
}
}
// Close the handle to the data file
xcaliburAccessor.CloseRawFile();
// Read the file info from the file system
// (much of this is already in datasetFileInfo, but we'll call UpdateDatasetFileStats() anyway to make sure all of the necessary steps are taken)
UpdateDatasetFileStats(fiRawFile, intDatasetID);
// Copy over the updated filetime info from datasetFileInfo to mDatasetFileInfo
mDatasetStatsSummarizer.DatasetFileInfo.FileSystemCreationTime = datasetFileInfo.FileSystemCreationTime;
mDatasetStatsSummarizer.DatasetFileInfo.FileSystemModificationTime = datasetFileInfo.FileSystemModificationTime;
mDatasetStatsSummarizer.DatasetFileInfo.DatasetID = datasetFileInfo.DatasetID;
mDatasetStatsSummarizer.DatasetFileInfo.DatasetName = string.Copy(datasetFileInfo.DatasetName);
mDatasetStatsSummarizer.DatasetFileInfo.FileExtension = string.Copy(datasetFileInfo.FileExtension);
mDatasetStatsSummarizer.DatasetFileInfo.AcqTimeStart = datasetFileInfo.AcqTimeStart;
mDatasetStatsSummarizer.DatasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeEnd;
mDatasetStatsSummarizer.DatasetFileInfo.ScanCount = datasetFileInfo.ScanCount;
mDatasetStatsSummarizer.DatasetFileInfo.FileSizeBytes = datasetFileInfo.FileSizeBytes;
// Delete the local copy of the data file
if (blnDeleteLocalFile)
{
try
{
File.Delete(strDataFilePathLocal);
}
catch (Exception)
{
// Deletion failed
OnErrorEvent("Deletion failed for: " + Path.GetFileName(strDataFilePathLocal));
}
}
return(!blnReadError);
}
private void LoadScanDetails(XRawFileIO objXcaliburAccessor)
{
OnStatusEvent(" Loading scan details");
if (mSaveTICAndBPI)
{
// Initialize the TIC and BPI arrays
InitializeTICAndBPI();
}
if (mSaveLCMS2DPlots)
{
InitializeLCMS2DPlot();
}
var dtLastProgressTime = DateTime.UtcNow;
var scanCount = objXcaliburAccessor.GetNumScans();
GetStartAndEndScans(scanCount, out var scanStart, out var scanEnd);
for (var scanNumber = scanStart; scanNumber <= scanEnd; scanNumber++)
{
clsScanInfo scanInfo;
try
{
var blnSuccess = objXcaliburAccessor.GetScanInfo(scanNumber, out scanInfo);
if (blnSuccess)
{
if (mSaveTICAndBPI)
{
mTICandBPIPlot.AddData(
scanNumber,
scanInfo.MSLevel,
(float)scanInfo.RetentionTime,
scanInfo.BasePeakIntensity,
scanInfo.TotalIonCurrent);
}
var objScanStatsEntry = new clsScanStatsEntry
{
ScanNumber = scanNumber,
ScanType = scanInfo.MSLevel,
ScanTypeName = XRawFileIO.GetScanTypeNameFromFinniganScanFilterText(scanInfo.FilterText),
ScanFilterText = XRawFileIO.MakeGenericFinniganScanFilter(scanInfo.FilterText),
ElutionTime = scanInfo.RetentionTime.ToString("0.0###"),
TotalIonIntensity = StringUtilities.ValueToString(scanInfo.TotalIonCurrent, 5),
BasePeakIntensity = StringUtilities.ValueToString(scanInfo.BasePeakIntensity, 5),
BasePeakMZ = scanInfo.BasePeakMZ.ToString("0.0###"),
BasePeakSignalToNoiseRatio = "0",
IonCount = scanInfo.NumPeaks,
IonCountRaw = scanInfo.NumPeaks
};
// Store the ScanEvent values in .ExtendedScanInfo
StoreExtendedScanInfo(ref objScanStatsEntry.ExtendedScanInfo, scanInfo.ScanEvents);
// Store the collision mode and the scan filter text
objScanStatsEntry.ExtendedScanInfo.CollisionMode = scanInfo.CollisionMode;
objScanStatsEntry.ExtendedScanInfo.ScanFilterText = scanInfo.FilterText;
mDatasetStatsSummarizer.AddDatasetScan(objScanStatsEntry);
}
}
catch (Exception ex)
{
OnErrorEvent("Error loading header info for scan " + scanNumber + ": " + ex.Message);
continue;
}
try
{
if (mSaveLCMS2DPlots | mCheckCentroidingStatus)
{
// Also need to load the raw data
// Load the ions for this scan
var intIonCount = objXcaliburAccessor.GetScanData2D(scanNumber, out var dblMassIntensityPairs);
if (intIonCount > 0)
{
if (mSaveLCMS2DPlots)
{
mLCMS2DPlot.AddScan2D(scanNumber, scanInfo.MSLevel, (float)scanInfo.RetentionTime, intIonCount, dblMassIntensityPairs);
}
if (mCheckCentroidingStatus)
{
var mzCount = dblMassIntensityPairs.GetLength(1);
var lstMZs = new List <double>(mzCount);
for (var i = 0; i <= mzCount - 1; i++)
{
lstMZs.Add(dblMassIntensityPairs[0, i]);
}
var centroidingStatus = GetCentroidStatus(scanNumber, scanInfo);
mDatasetStatsSummarizer.ClassifySpectrum(lstMZs, scanInfo.MSLevel, centroidingStatus);
}
}
}
}
catch (Exception ex)
{
OnErrorEvent("Error loading m/z and intensity values for scan " + scanNumber + ": " + ex.Message);
}
var percentComplete = scanNumber / (float)scanCount * 100;
OnProgressUpdate("Scans processed: " + scanNumber, percentComplete);
ShowProgress(scanNumber, scanCount, ref dtLastProgressTime);
}
Console.WriteLine();
}
public override int GetNumMSScans()
{
return(mRawFileReader.GetNumScans());
}
/// <summary>
/// Read scan data and ions from a Thermo .raw file
/// </summary>
/// <param name="filePath"></param>
/// <param name="scanList"></param>
/// <param name="spectraCache"></param>
/// <param name="dataOutputHandler"></param>
/// <param name="keepRawSpectra"></param>
/// <param name="keepMSMSSpectra"></param>
/// <returns>True if Success, False if failure</returns>
/// <remarks>Assumes filePath exists</remarks>
public bool ExtractScanInfoFromXcaliburDataFile(
string filePath,
clsScanList scanList,
clsSpectraCache spectraCache,
clsDataOutput dataOutputHandler,
bool keepRawSpectra,
bool keepMSMSSpectra)
{
// Use XrawFileIO to read the .Raw files (it uses ThermoFisher.CommonCore)
var readerOptions = new ThermoReaderOptions
{
LoadMSMethodInfo = mOptions.WriteMSMethodFile,
LoadMSTuneInfo = mOptions.WriteMSTuneFile
};
var xcaliburAccessor = new XRawFileIO(readerOptions)
{
ScanInfoCacheMaxSize = 0 // Don't cache scanInfo objects
};
RegisterEvents(xcaliburAccessor);
mBpiUpdateCount = 0;
// Assume success for now
var success = true;
try
{
Console.Write("Reading Thermo .raw file ");
ReportMessage("Reading Thermo .raw file");
UpdateProgress(0, "Opening data file:" + Environment.NewLine + Path.GetFileName(filePath));
// Obtain the full path to the file
var rawFileInfo = new FileInfo(filePath);
var inputFileFullPath = rawFileInfo.FullName;
// Open a handle to the data file
if (!xcaliburAccessor.OpenRawFile(inputFileFullPath))
{
ReportError("Error opening input data file: " + inputFileFullPath + " (xcaliburAccessor.OpenRawFile returned False)");
SetLocalErrorCode(clsMASIC.eMasicErrorCodes.InputFileAccessError);
return(false);
}
var datasetID = mOptions.SICOptions.DatasetID;
success = UpdateDatasetFileStats(rawFileInfo, datasetID, xcaliburAccessor);
var metadataWriter = new clsThermoMetadataWriter();
RegisterEvents(metadataWriter);
if (mOptions.WriteMSMethodFile)
{
metadataWriter.SaveMSMethodFile(xcaliburAccessor, dataOutputHandler);
}
if (mOptions.WriteMSTuneFile)
{
metadataWriter.SaveMSTuneFile(xcaliburAccessor, dataOutputHandler);
}
var scanCount = xcaliburAccessor.GetNumScans();
if (scanCount <= 0)
{
// No scans found
ReportError("No scans found in the input file: " + filePath);
SetLocalErrorCode(clsMASIC.eMasicErrorCodes.InputFileAccessError);
return(false);
}
var scanStart = xcaliburAccessor.ScanStart;
var scanEnd = xcaliburAccessor.ScanEnd;
InitOptions(scanList, keepRawSpectra, keepMSMSSpectra);
UpdateProgress(string.Format("Reading Xcalibur data ({0:N0} scans){1}", scanCount, Environment.NewLine + Path.GetFileName(filePath)));
ReportMessage(string.Format("Reading Xcalibur data; Total scan count: {0:N0}", scanCount));
var scanCountToRead = scanEnd - scanStart + 1;
var scansEst = mOptions.SICOptions.ScanRangeCount;
if (scansEst <= 0)
{
scansEst = scanCountToRead;
}
scanList.ReserveListCapacity(scansEst);
mScanTracking.ReserveListCapacity(scansEst);
spectraCache.SpectrumCount = Math.Max(spectraCache.SpectrumCount, scansEst);
for (var scanNumber = scanStart; scanNumber <= scanEnd; scanNumber++)
{
if (!mScanTracking.CheckScanInRange(scanNumber, mOptions.SICOptions))
{
mScansOutOfRange += 1;
continue;
}
success = xcaliburAccessor.GetScanInfo(scanNumber, out ThermoRawFileReader.clsScanInfo thermoScanInfo);
if (!success)
{
// GetScanInfo returned false
ReportWarning("xcaliburAccessor.GetScanInfo returned false for scan " + scanNumber.ToString() + "; aborting read");
break;
}
var percentComplete = scanList.MasterScanOrderCount / (double)(scanCountToRead) * 100;
var extractSuccess = ExtractScanInfoCheckRange(xcaliburAccessor, thermoScanInfo, scanList, spectraCache, dataOutputHandler, percentComplete);
if (!extractSuccess)
{
break;
}
}
Console.WriteLine();
scanList.SetListCapacityToCount();
mScanTracking.SetListCapacityToCount();
// Shrink the memory usage of the scanList arrays
success = FinalizeScanList(scanList, rawFileInfo);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
ReportError("Error in ExtractScanInfoFromXcaliburDataFile", ex, clsMASIC.eMasicErrorCodes.InputFileDataReadError);
}
// Close the handle to the data file
xcaliburAccessor.CloseRawFile();
return(success);
}
public List <CompoundData> ReadSpectraData(List <CompoundData> combinedTransitions)
{
var scanTimes = new Dictionary <int, double>();
using (var rawReader = new XRawFileIO(DatasetPath))
{
var numScans = rawReader.GetNumScans();
if (numScans <= 0)
{
// dataset has no MS data. Return.
return(null);
}
for (var i = 1; i <= numScans; i++)
{
var err = rawReader.GetRetentionTime(i, out double time);
scanTimes.Add(i, time);
// Filter string parsing for speed: "+ c NSI SRM ms2 [precursor/parent m/z] [[list of product m/z ranges]]
}
// Map transition start/stop times to scans
var scansAndTargets = new Dictionary <int, List <CompoundData> >();
foreach (var scan in scanTimes)
{
var matches = combinedTransitions
.Where(x => x.StartTimeMinutes <= scan.Value && scan.Value <= x.StopTimeMinutes).ToList();
if (matches.Count > 0)
{
scansAndTargets.Add(scan.Key, matches);
}
}
rawReader.ScanInfoCacheMaxSize = 2;
// read spectra data for each transition from the file, in an optimized fashion
foreach (var scan in scansAndTargets)
{
rawReader.GetScanInfo(scan.Key, out clsScanInfo scanInfo);
var preMz = scanInfo.ParentIonMZ;
rawReader.GetScanData(scan.Key, out var mzs, out var intensities);
foreach (var compound in scan.Value.Where(x => Math.Abs(x.PrecursorMz - preMz) < 0.01))
{
foreach (var massRange in scanInfo.MRMInfo.MRMMassList)
{
var match = compound.Transitions.FirstOrDefault(x => massRange.StartMass <= x.ProductMz && x.ProductMz <= massRange.EndMass);
if (match == null)
{
continue;
}
for (var j = 0; j < mzs.Length; j++)
{
var mz = mzs[j];
var intensity = intensities[j];
if (massRange.StartMass <= mz && mz <= massRange.EndMass)
{
match.IntensitySum += intensity;
match.Intensities.Add(new TransitionData.DataPoint(scan.Key, scanTimes[scan.Key], intensity));
if (intensity > match.MaxIntensity)
{
match.MaxIntensity = intensity;
match.MaxIntensityTime = scanTimes[scan.Key];
}
}
}
}
}
}
}
return(combinedTransitions.ToList());
}
