private List <udtScansDataType> LoadScansFile(string strScansFilePath)
{
const string FILTERED_SCANS_SUFFIX = "_filtered_scans.csv";
var dctColumnInfo = new Dictionary <string, int>
{
{ "type", -1 },
{ "bpi", -1 },
{ "bpi_mz", -1 },
{ "tic", -1 },
{ "num_peaks", -1 },
{ "num_deisotoped", -1 }
};
var intColIndexScanOrFrameNum = -1;
var intColIndexScanOrFrameTime = -1;
var lstScanData = new List <udtScansDataType>();
var intRowNumber = 0;
var intColIndexScanInfo = -1;
if (!File.Exists(strScansFilePath) && strScansFilePath.ToLower().EndsWith(FILTERED_SCANS_SUFFIX))
{
strScansFilePath = strScansFilePath.Substring(0, strScansFilePath.Length - FILTERED_SCANS_SUFFIX.Length) + "_scans.csv";
}
if (!File.Exists(strScansFilePath))
{
OnWarningEvent("Warning: _scans.csv file is missing; will plot vs. scan number instead of vs. elution time");
return(lstScanData);
}
Console.WriteLine(" Reading the _scans.csv file");
using (var srIsosFile = new StreamReader(new FileStream(strScansFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
while (!srIsosFile.EndOfStream)
{
intRowNumber += 1;
var strLineIn = srIsosFile.ReadLine();
if (strLineIn == null)
{
continue;
}
var lstData = strLineIn.Split(',').ToList();
if (intRowNumber == 1)
{
// Parse the header row
ParseColumnHeaders(dctColumnInfo, lstData, "_scans.csv");
intColIndexScanOrFrameNum = GetScanOrFrameColIndex(lstData, "_scans.csv");
intColIndexScanOrFrameTime = lstData.IndexOf("frame_time");
if (intColIndexScanOrFrameTime < 0)
{
intColIndexScanOrFrameTime = lstData.IndexOf("scan_time");
}
// The info column will have data of the form "FTMS + p NSI Full ms [400.00-2000.00]" for Thermo datasets
// For .mzXML files, this fill will simply have an integer (and thus isn't useful)
// It may not be present in older _scancs.csv files and is thus optional
intColIndexScanInfo = lstData.IndexOf("info");
continue;
}
try
{
var udtScanData = new udtScansDataType();
int.TryParse(lstData[intColIndexScanOrFrameNum], out udtScanData.Scan);
float.TryParse(lstData[intColIndexScanOrFrameTime], out udtScanData.ElutionTime);
int.TryParse(lstData[dctColumnInfo["type"]], out udtScanData.MSLevel);
double.TryParse(lstData[dctColumnInfo["bpi"]], out udtScanData.BasePeakIntensity);
double.TryParse(lstData[dctColumnInfo["bpi_mz"]], out udtScanData.BasePeakMZ);
double.TryParse(lstData[dctColumnInfo["tic"]], out udtScanData.TotalIonCurrent);
int.TryParse(lstData[dctColumnInfo["num_peaks"]], out udtScanData.NumPeaks);
int.TryParse(lstData[dctColumnInfo["num_deisotoped"]], out udtScanData.NumDeisotoped);
if (intColIndexScanInfo > 0)
{
var infoText = lstData[intColIndexScanInfo];
// Only store infoText in .FilterText if infoText is not simply an integer
if (!int.TryParse(infoText, out _))
{
udtScanData.FilterText = infoText;
}
}
lstScanData.Add(udtScanData);
if (mSaveTICAndBPI)
{
mTICandBPIPlot.AddData(udtScanData.Scan, udtScanData.MSLevel, udtScanData.ElutionTime, udtScanData.BasePeakIntensity, udtScanData.TotalIonCurrent);
}
string scanTypeName;
if (string.IsNullOrWhiteSpace(udtScanData.FilterText))
{
udtScanData.FilterText = udtScanData.MSLevel > 1 ? "HMSn" : "HMS";
scanTypeName = udtScanData.FilterText;
}
else
{
scanTypeName = XRawFileIO.GetScanTypeNameFromFinniganScanFilterText(udtScanData.FilterText);
}
var objScanStatsEntry = new clsScanStatsEntry
{
ScanNumber = udtScanData.Scan,
ScanType = udtScanData.MSLevel,
ScanTypeName = scanTypeName,
ScanFilterText = XRawFileIO.MakeGenericFinniganScanFilter(udtScanData.FilterText),
ElutionTime = udtScanData.ElutionTime.ToString("0.0###"),
TotalIonIntensity = StringUtilities.ValueToString(udtScanData.TotalIonCurrent, 5),
BasePeakIntensity = StringUtilities.ValueToString(udtScanData.BasePeakIntensity, 5),
BasePeakMZ = udtScanData.BasePeakMZ.ToString("0.0###"),
BasePeakSignalToNoiseRatio = "0",
IonCount = udtScanData.NumDeisotoped,
IonCountRaw = udtScanData.NumPeaks,
ExtendedScanInfo =
{
CollisionMode = string.Empty,
ScanFilterText = udtScanData.FilterText
}
};
mDatasetStatsSummarizer.AddDatasetScan(objScanStatsEntry);
}
catch (Exception ex)
{
OnWarningEvent("Warning: Ignoring scan " + lstData[dctColumnInfo["scan_num"]] + " since data conversion error: " + ex.Message);
}
}
}
return(lstScanData);
}
private void LoadFrameDetails(
DataReader objUIMFReader,
IReadOnlyDictionary <int, DataReader.FrameType> dctMasterFrameList,
IReadOnlyList <int> intMasterFrameNumList)
{
const int BAD_TIC_OR_BPI = int.MinValue;
// The StartTime value for each frame is the number of minutes since 12:00 am
// If acquiring data from 11:59 pm through 12:00 am, then the StartTime will reset to zero
if (mSaveTICAndBPI)
{
// Initialize the TIC and BPI arrays
InitializeTICAndBPI();
mTICandBPIPlot.BPIXAxisLabel = "Frame number";
mTICandBPIPlot.TICXAxisLabel = "Frame number";
mInstrumentSpecificPlots.BPIXAxisLabel = "Frame number";
mInstrumentSpecificPlots.TICXAxisLabel = "Frame number";
mInstrumentSpecificPlots.TICYAxisLabel = "Pressure";
mInstrumentSpecificPlots.TICYAxisExponentialNotation = false;
mInstrumentSpecificPlots.TICPlotAbbrev = "Pressure";
mInstrumentSpecificPlots.TICAutoMinMaxY = true;
mInstrumentSpecificPlots.RemoveZeroesFromEnds = true;
}
if (mSaveLCMS2DPlots)
{
InitializeLCMS2DPlot();
}
var dtLastProgressTime = DateTime.UtcNow;
var objGlobalParams = objUIMFReader.GetGlobalParams();
var intGlobalMaxBins = objGlobalParams.Bins;
var dblMZList = new double[intGlobalMaxBins + 1];
var intIntensityList = new int[intGlobalMaxBins + 1];
var dblIonsIntensity = new double[intGlobalMaxBins + 1];
// Call .GetStartAndEndScans to get the start and end Frames
GetStartAndEndScans(objGlobalParams.NumFrames, out var intFrameStart, out var intFrameEnd);
// Construct the TIC and BPI (of all frames)
ConstructTICandBPI(objUIMFReader, intFrameStart, intFrameEnd, out var dctTIC, out var dctBPI);
Console.Write(" Loading frame details");
// Initialize the frame starttime variables
double dblFrameStartTimeInitial = -1;
double dblFrameStartTimeAddon = 0;
double dblFrameStartTimePrevious = -1;
double dblFrameStartTimeCurrent = 0;
for (var intMasterFrameNumIndex = 0; intMasterFrameNumIndex <= intMasterFrameNumList.Count - 1; intMasterFrameNumIndex++)
{
var intFrameNumber = intMasterFrameNumList[intMasterFrameNumIndex];
if (!dctMasterFrameList.TryGetValue(intFrameNumber, out var eFrameType))
{
OnWarningEvent(string.Format(
"Frametype {0} not found in dictionary dctMasterFrameList; ignoring frame {1} in LoadFrameDetails",
eFrameType, intFrameNumber));
continue;
}
// Check whether the frame number is within the desired range
if (intFrameNumber < intFrameStart || intFrameNumber > intFrameEnd)
{
continue;
}
try
{
FrameParams objFrameParams;
try
{
objFrameParams = objUIMFReader.GetFrameParams(intFrameNumber);
}
catch (Exception)
{
Console.WriteLine("Exception obtaining frame parameters for frame " + intFrameNumber + "; will skip this frame");
objFrameParams = null;
}
if (objFrameParams == null || eFrameType == DataReader.FrameType.Calibration)
{
continue;
}
var intNonZeroPointsInFrame = objUIMFReader.GetCountPerFrame(intFrameNumber);
int intMSLevel;
if (objFrameParams.FrameType == DataReader.FrameType.MS2)
{
intMSLevel = 2;
}
else
{
intMSLevel = 1;
}
// Read the frame StartTime
// This will be zero in older .UIMF files, or in files converted from Agilent .D folders
// In newer files, it is the number of minutes since 12:00 am
dblFrameStartTimeCurrent = objFrameParams.GetValueDouble(FrameParamKeyType.StartTimeMinutes);
if (intMasterFrameNumIndex == 0 || dblFrameStartTimeInitial < -0.9)
{
dblFrameStartTimeInitial = dblFrameStartTimeCurrent;
}
if (dblFrameStartTimePrevious > 1400 && dblFrameStartTimePrevious > dblFrameStartTimeCurrent)
{
// We likely rolled over midnight; bump up dblFrameStartTimeAddon by 1440 minutes
dblFrameStartTimeAddon += 60 * 24;
}
// Compute the elution time (in minutes) of this frame
var dblElutionTime = dblFrameStartTimeCurrent + dblFrameStartTimeAddon - dblFrameStartTimeInitial;
if (!dctBPI.TryGetValue(intFrameNumber, out var dblBPI))
{
dblBPI = BAD_TIC_OR_BPI;
}
if (!dctTIC.TryGetValue(intFrameNumber, out var dblTIC))
{
dblTIC = BAD_TIC_OR_BPI;
}
if (mSaveTICAndBPI)
{
if (dblTIC > BAD_TIC_OR_BPI && dblTIC > BAD_TIC_OR_BPI)
{
mTICandBPIPlot.AddData(intFrameNumber, intMSLevel, (float)dblElutionTime, dblBPI, dblTIC);
}
var dblPressure = objFrameParams.GetValueDouble(FrameParamKeyType.PressureBack);
if (Math.Abs(dblPressure) < float.Epsilon)
{
dblPressure = objFrameParams.GetValueDouble(FrameParamKeyType.RearIonFunnelPressure);
}
if (Math.Abs(dblPressure) < float.Epsilon)
{
dblPressure = objFrameParams.GetValueDouble(FrameParamKeyType.IonFunnelTrapPressure);
}
if (Math.Abs(dblPressure) < float.Epsilon)
{
dblPressure = objFrameParams.GetValueDouble(FrameParamKeyType.PressureFront);
}
mInstrumentSpecificPlots.AddDataTICOnly(intFrameNumber, intMSLevel, (float)dblElutionTime, dblPressure);
}
var objScanStatsEntry = new clsScanStatsEntry
{
ScanNumber = intFrameNumber,
ScanType = intMSLevel
};
if (intMSLevel <= 1)
{
objScanStatsEntry.ScanTypeName = "HMS";
}
else
{
objScanStatsEntry.ScanTypeName = "HMSn";
}
objScanStatsEntry.ScanFilterText = "";
objScanStatsEntry.ElutionTime = dblElutionTime.ToString("0.0###");
if (dblTIC > BAD_TIC_OR_BPI)
{
objScanStatsEntry.TotalIonIntensity = StringUtilities.ValueToString(dblTIC, 5);
}
else
{
objScanStatsEntry.TotalIonIntensity = "0";
}
if (dblBPI > BAD_TIC_OR_BPI)
{
objScanStatsEntry.BasePeakIntensity = StringUtilities.ValueToString(dblBPI, 5);
}
else
{
objScanStatsEntry.BasePeakIntensity = "0";
}
objScanStatsEntry.BasePeakMZ = "0";
// Base peak signal to noise ratio
objScanStatsEntry.BasePeakSignalToNoiseRatio = "0";
objScanStatsEntry.IonCount = intNonZeroPointsInFrame;
objScanStatsEntry.IonCountRaw = intNonZeroPointsInFrame;
mDatasetStatsSummarizer.AddDatasetScan(objScanStatsEntry);
if (mSaveLCMS2DPlots | mCheckCentroidingStatus)
{
try
{
// Also need to load the raw data
// We have to clear the m/z and intensity arrays before calling GetSpectrum
Array.Clear(dblMZList, 0, dblMZList.Length);
Array.Clear(intIntensityList, 0, intIntensityList.Length);
// Process all of the IMS scans in this Frame to compute a summed spectrum representative of the frame
// In UIMF files from IMS04, if Frame_Parameters.Scans = 360 then Frame_Scans will have scans 0 through 359
// In UIMF files from IMS08, prior to December 1, 2014, if Frame_Parameters.Scans = 374 then Frame_Scans will have scans 0 through 373
// in UIMF files from IMS08, after December 1, 2014 if Frame_Parameters.Scans = 374 then Frame_Scans will have scans 1 through 374
var intIonCount = objUIMFReader.GetSpectrum(intFrameNumber, intFrameNumber, eFrameType, 0, objFrameParams.Scans, out dblMZList, out intIntensityList);
if (intIonCount > 0)
{
// The m/z and intensity arrays might contain entries with m/z values of 0;
// need to copy the data in place to get the data in the correct format.
// In addition, we'll copy the intensity values from intIntensityList() into dblIonsIntensity()
if (intIonCount > dblMZList.Length)
{
intIonCount = dblMZList.Length;
}
if (dblIonsIntensity.Length < intIonCount)
{
Array.Resize(ref dblIonsIntensity, intIonCount);
}
var intTargetIndex = 0;
for (var intIonIndex = 0; intIonIndex <= intIonCount - 1; intIonIndex++)
{
if (dblMZList[intIonIndex] > 0)
{
dblMZList[intTargetIndex] = dblMZList[intIonIndex];
dblIonsIntensity[intTargetIndex] = intIntensityList[intIonIndex];
intTargetIndex += 1;
}
}
intIonCount = intTargetIndex;
if (intIonCount > 0)
{
if (dblIonsIntensity.Length > intIonCount)
{
Array.Resize(ref dblIonsIntensity, intIonCount);
}
if (mSaveLCMS2DPlots)
{
mLCMS2DPlot.AddScan(intFrameNumber, intMSLevel, (float)dblElutionTime, intIonCount, dblMZList, dblIonsIntensity);
}
if (mCheckCentroidingStatus)
{
mDatasetStatsSummarizer.ClassifySpectrum(intIonCount, dblMZList, intMSLevel);
}
}
}
}
catch (Exception ex)
{
OnWarningEvent("Error loading m/z and intensity values for frame " + intFrameNumber + ": " + ex.Message);
}
}
}
catch (Exception ex)
{
OnWarningEvent("Error loading header info for frame " + intFrameNumber + ": " + ex.Message);
}
var percentComplete = intMasterFrameNumIndex / (float)intMasterFrameNumList.Count * 100;
OnProgressUpdate("Frames processed: " + intMasterFrameNumIndex, percentComplete);
ShowProgress(intMasterFrameNumIndex, intMasterFrameNumList.Count, ref dtLastProgressTime);
dblFrameStartTimePrevious = dblFrameStartTimeCurrent;
}
Console.WriteLine();
}
private bool ProcessChemstationMSDataFile(string strDatafilePath, clsDatasetFileInfo datasetFileInfo)
{
bool blnSuccess;
var intCurrentIndex = 0;
try {
using (var oReader = new ChemstationMSFileReader.clsChemstationDataMSFileReader(strDatafilePath)) {
datasetFileInfo.AcqTimeStart = oReader.Header.AcqDate;
datasetFileInfo.AcqTimeEnd = datasetFileInfo.AcqTimeStart.AddMinutes(oReader.Header.RetentionTimeMinutesEnd);
datasetFileInfo.ScanCount = oReader.Header.SpectraCount;
for (var intSpectrumIndex = 0; intSpectrumIndex <= datasetFileInfo.ScanCount - 1; intSpectrumIndex++)
{
intCurrentIndex = intSpectrumIndex;
ChemstationMSFileReader.clsSpectralRecord oSpectrum = null;
List <float> lstMZs = null;
List <Int32> lstIntensities = null;
const int intMSLevel = 1;
bool blnValidSpectrum;
try {
oReader.GetSpectrum(intSpectrumIndex, ref oSpectrum);
lstMZs = oSpectrum.Mzs;
lstIntensities = oSpectrum.Intensities;
blnValidSpectrum = true;
} catch (Exception ex) {
OnWarningEvent("Exception obtaining data from the MS file for spectrum index " + intCurrentIndex + ": " + ex.Message);
blnValidSpectrum = false;
}
if (blnValidSpectrum)
{
var objScanStatsEntry = new clsScanStatsEntry
{
ScanNumber = intSpectrumIndex + 1,
ScanType = intMSLevel,
ScanTypeName = "GC-MS",
ScanFilterText = "",
ElutionTime = oSpectrum.RetentionTimeMinutes.ToString("0.0###"),
TotalIonIntensity = StringUtilities.ValueToString(oSpectrum.TIC, 1),
BasePeakIntensity = StringUtilities.ValueToString(oSpectrum.BasePeakAbundance, 1),
BasePeakMZ = oSpectrum.BasePeakMZ.ToString("0.0###"),
BasePeakSignalToNoiseRatio = "0",
IonCount = lstMZs.Count
};
objScanStatsEntry.IonCountRaw = objScanStatsEntry.IonCount;
mDatasetStatsSummarizer.AddDatasetScan(objScanStatsEntry);
if (mSaveTICAndBPI)
{
mTICandBPIPlot.AddData(objScanStatsEntry.ScanNumber, intMSLevel, oSpectrum.RetentionTimeMinutes, oSpectrum.BasePeakAbundance, oSpectrum.TIC);
if (lstMZs.Count > 0)
{
var dblIonsMZ = new double[lstMZs.Count];
var dblIonsIntensity = new double[lstMZs.Count];
for (var intIndex = 0; intIndex <= lstMZs.Count - 1; intIndex++)
{
dblIonsMZ[intIndex] = lstMZs[intIndex];
dblIonsIntensity[intIndex] = lstIntensities[intIndex];
}
mLCMS2DPlot.AddScan(objScanStatsEntry.ScanNumber, intMSLevel, oSpectrum.RetentionTimeMinutes, dblIonsMZ.Length, dblIonsMZ, dblIonsIntensity);
}
}
if (mCheckCentroidingStatus)
{
var lstMzDoubles = new List <double>(lstMZs.Count);
lstMzDoubles.AddRange(lstMZs.Select(ion => (double)ion));
mDatasetStatsSummarizer.ClassifySpectrum(lstMzDoubles, intMSLevel);
}
}
}
}
blnSuccess = true;
} catch (Exception ex) {
// Exception reading file
OnWarningEvent("Exception reading data from the MS file at spectrum index " + intCurrentIndex + ": " + ex.Message);
blnSuccess = false;
}
return(blnSuccess);
}
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();
}
/// <summary>
/// Examines the subdirectories in the specified zip file
/// Determines the oldest and newest modified analysis.baf files (or apexAcquisition.method file if analysis.baf files are not found)
/// Presumes this is the AcqStartTime and AcqEndTime
/// </summary>
/// <param name="fiZipFile"></param>
/// <param name="datasetFileInfo"></param>
/// <returns>True if at least one valid file is found; otherwise false</returns>
/// <remarks></remarks>
private void DetermineAcqStartEndTime(FileInfo fiZipFile, clsDatasetFileInfo datasetFileInfo)
{
var blnSuccess = false;
try
{
// Bump up the file size
datasetFileInfo.FileSizeBytes += fiZipFile.Length;
var lstFileNamesToFind = new List <string> {
"analysis.baf",
"apexAcquisition.method",
"submethods.xml"
};
var oZipFile = new Ionic.Zip.ZipFile(fiZipFile.FullName);
foreach (var strFileNameToFind in lstFileNamesToFind)
{
using (var oZipEntry = oZipFile.GetEnumerator())
{
while (oZipEntry.MoveNext())
{
if (oZipEntry.Current == null)
{
continue;
}
if (oZipEntry.Current.IsDirectory)
{
continue;
}
// Split the filename on the forward slash character
var strNameParts = oZipEntry.Current.FileName.Split('/');
if (strNameParts.Length <= 0)
{
continue;
}
if (!string.Equals(strNameParts[strNameParts.Length - 1], strFileNameToFind, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
if (oZipEntry.Current.LastModified < datasetFileInfo.AcqTimeStart)
{
datasetFileInfo.AcqTimeStart = oZipEntry.Current.LastModified;
}
if (oZipEntry.Current.LastModified > datasetFileInfo.AcqTimeEnd)
{
datasetFileInfo.AcqTimeEnd = oZipEntry.Current.LastModified;
}
// Bump up the scan count
datasetFileInfo.ScanCount += 1;
// Add a Scan Stats entry
var objScanStatsEntry = new clsScanStatsEntry
{
ScanNumber = datasetFileInfo.ScanCount,
ScanType = 1,
ScanTypeName = "MALDI-HMS",
ScanFilterText = "",
ElutionTime = "0",
TotalIonIntensity = "0",
BasePeakIntensity = "0",
BasePeakMZ = "0",
BasePeakSignalToNoiseRatio = "0",
IonCount = 0,
IonCountRaw = 0
};
// Base peak signal to noise ratio
mDatasetStatsSummarizer.AddDatasetScan(objScanStatsEntry);
blnSuccess = true;
}
}
if (blnSuccess)
{
break;
}
}
}
catch (Exception ex)
{
OnErrorEvent("Error in DetermineAcqStartEndTime: " + ex.Message);
}
}
