/// <summary>
/// Tests the dynamic connection for ThermoRawFileReader
/// </summary>
public static void TestDynamicConnectionRawFileReader()
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var path1 = Path.Combine(TestContext.CurrentContext.TestDirectory, "DataFiles", "small.raw");
var dynamicConnection1 = new ThermoDynamicData(path1);
var path2 = Path.Combine(TestContext.CurrentContext.TestDirectory, "DataFiles", "testFileWMS2.raw");
var dynamicConnection2 = new ThermoDynamicData(path2);
var msOrders = dynamicConnection1.MsOrdersByScan;
Assert.That(msOrders != null && msOrders.Length > 0);
var a = dynamicConnection1.GetOneBasedScanFromDynamicConnection(1);
Assert.That(a != null);
var b = dynamicConnection2.GetOneBasedScanFromDynamicConnection(1);
Assert.That(b != null);
Assert.That(a.MassSpectrum.XArray.Length != b.MassSpectrum.XArray.Length);
a = dynamicConnection1.GetOneBasedScanFromDynamicConnection(10000);
Assert.That(a == null);
dynamicConnection1.CloseDynamicConnection();
dynamicConnection2.CloseDynamicConnection();
Console.WriteLine($"Analysis time for TestDynamicConnectionRawFileReader: {stopwatch.Elapsed.Hours}h {stopwatch.Elapsed.Minutes}m {stopwatch.Elapsed.Seconds}s");
}
public static void TestDynamicRaw(string fileName)
{
string filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "DataFiles", fileName);
ThermoRawFileReader staticRaw = ThermoRawFileReader.LoadAllStaticData(filePath);
ThermoDynamicData dynamicRaw = new ThermoDynamicData(filePath);
foreach (MsDataScan staticScan in staticRaw.GetAllScansList())
{
MsDataScan dynamicScan = dynamicRaw.GetOneBasedScanFromDynamicConnection(staticScan.OneBasedScanNumber);
Assert.That(dynamicScan.OneBasedScanNumber == staticScan.OneBasedScanNumber);
Assert.That(dynamicScan.MsnOrder == staticScan.MsnOrder);
Assert.That(dynamicScan.RetentionTime == staticScan.RetentionTime);
Assert.That(dynamicScan.Polarity == staticScan.Polarity);
Assert.That(dynamicScan.ScanWindowRange.Minimum == staticScan.ScanWindowRange.Minimum);
Assert.That(dynamicScan.ScanWindowRange.Maximum == staticScan.ScanWindowRange.Maximum);
Assert.That(dynamicScan.ScanFilter == staticScan.ScanFilter);
Assert.That(dynamicScan.NativeId == staticScan.NativeId);
Assert.That(dynamicScan.IsCentroid == staticScan.IsCentroid);
Assert.That(dynamicScan.IsCentroid == staticScan.IsCentroid);
Assert.That(dynamicScan.InjectionTime == staticScan.InjectionTime);
Assert.That(dynamicScan.NoiseData == staticScan.NoiseData);
Assert.That(dynamicScan.IsolationMz == staticScan.IsolationMz);
Assert.That(dynamicScan.SelectedIonChargeStateGuess == staticScan.SelectedIonChargeStateGuess);
Assert.That(dynamicScan.SelectedIonIntensity == staticScan.SelectedIonIntensity);
Assert.That(dynamicScan.SelectedIonMZ == staticScan.SelectedIonMZ);
Assert.That(dynamicScan.DissociationType == staticScan.DissociationType);
Assert.That(dynamicScan.IsolationWidth == staticScan.IsolationWidth);
Assert.That(dynamicScan.OneBasedPrecursorScanNumber == staticScan.OneBasedPrecursorScanNumber);
Assert.That(dynamicScan.SelectedIonMonoisotopicGuessIntensity == staticScan.SelectedIonMonoisotopicGuessIntensity);
Assert.That(dynamicScan.SelectedIonMonoisotopicGuessMz == staticScan.SelectedIonMonoisotopicGuessMz);
if (dynamicScan.IsolationRange != null || staticScan.IsolationRange != null)
{
Assert.That(dynamicScan.IsolationRange.Minimum == staticScan.IsolationRange.Minimum);
Assert.That(dynamicScan.IsolationRange.Maximum == staticScan.IsolationRange.Maximum);
}
Assert.That(dynamicScan.MassSpectrum.XArray.Length == staticScan.MassSpectrum.XArray.Length);
Assert.That(dynamicScan.MassSpectrum.YArray.Length == staticScan.MassSpectrum.YArray.Length);
for (int i = 0; i < staticScan.MassSpectrum.XArray.Length; i++)
{
double staticMz = staticScan.MassSpectrum.XArray[i];
double staticIntensity = staticScan.MassSpectrum.YArray[i];
double dynamicMz = dynamicScan.MassSpectrum.XArray[i];
double dynamicIntensity = dynamicScan.MassSpectrum.YArray[i];
Assert.That(dynamicMz == staticMz);
Assert.That(dynamicIntensity == staticIntensity);
}
}
}
public static void ThermoDynamicTest()
{
ThermoDynamicData dynamicThermo = ThermoDynamicData.InitiateDynamicConnection(@"testFileWMS2.raw");
var ms1scan = dynamicThermo.GetOneBasedScan(1);
MsDataScan ms2scan = dynamicThermo.GetOneBasedScan(651);
Assert.That(ms1scan.OneBasedScanNumber == 1);
Assert.That(ms2scan.OneBasedScanNumber == 651);
Assert.That(Math.Round(ms2scan.RetentionTime, 2) == 12.16);
Assert.That(ms2scan.OneBasedPrecursorScanNumber == 650);
Assert.That(ms2scan.SelectedIonMZ == 442.67);
var t = dynamicThermo.ThermoGlobalParams.MsOrderByScan;
Assert.That(t[0] == 1);
Assert.That(t[5] == 1);
Assert.That(t[649] == 1);
Assert.That(t[650] == 2);
Assert.That(!t.Where(v => v == 0).Any());
}
private void LoadSpectraFiles(out List <string> errors)
{
errors = new List <string>();
foreach (var filepath in SpectraFilePaths)
{
lock (ThreadLocker)
{
var fileNameWithoutExtension = filepath.Replace(GlobalVariables.GetFileExtension(filepath), string.Empty);
fileNameWithoutExtension = System.IO.Path.GetFileName(fileNameWithoutExtension);
DynamicDataConnection spectraFile = null;
string extension = GlobalVariables.GetFileExtension(filepath);
if (extension.Equals(".mzML", StringComparison.OrdinalIgnoreCase))
{
spectraFile = new MzmlDynamicData(filepath);
}
else if (extension.Equals(".mgf", StringComparison.OrdinalIgnoreCase))
{
spectraFile = new MgfDynamicData(filepath);
}
else if (extension.Equals(".raw", StringComparison.OrdinalIgnoreCase))
{
spectraFile = new ThermoDynamicData(filepath);
}
else
{
errors.Add("Unrecognized spectra file type: " + extension);
continue;
}
if (!MsDataFiles.TryAdd(fileNameWithoutExtension, spectraFile))
{
spectraFile.CloseDynamicConnection();
// print warning? but probably unnecessary. this means the data file was loaded twice.
// which is an error but not an important one because the data is loaded
}
}
}
}
public static void LoadThermoTest2()
{
ThermoStaticData a = ThermoStaticData.LoadAllStaticData(@"05-13-16_cali_MS_60K-res_MS.raw");
Assert.AreEqual(360, a.NumSpectra);
Assert.GreaterOrEqual(1000, a.GetOneBasedScan(1).MassSpectrum.Extract(0, 500).Last().Mz);
Assert.AreEqual(2, a.GetOneBasedScan(1).MassSpectrum.FilterByY(5e6, double.MaxValue).Count());
var ye = a.GetOneBasedScan(1).MassSpectrum.CopyTo2DArray();
Assert.AreEqual(77561752, a.GetOneBasedScan(1).TotalIonCurrent);
Assert.AreEqual(144, a.GetClosestOneBasedSpectrumNumber(2));
MzSpectrum newSpectrum = new MzSpectrum(a.GetOneBasedScan(51).MassSpectrum.XArray, a.GetOneBasedScan(51).MassSpectrum.YArray, true);
Assert.AreEqual(1120, a.GetOneBasedScan(1).MassSpectrum.Size);
var newDeconvolution = a.GetOneBasedScan(1).MassSpectrum.Deconvolute(new MzRange(double.MinValue, double.MaxValue), 1, 10, 1, 4).ToList();
Assert.IsTrue(newDeconvolution.Any(b => Math.Abs(b.peaks.First().mz.ToMass(b.charge) - 523.257) < 0.001));
MzmlMethods.CreateAndWriteMyMzmlWithCalibratedSpectra(a, Path.Combine(TestContext.CurrentContext.TestDirectory, "convertedThermo.mzML"), false);
var sdafaf = a.Deconvolute(null, null, 1, 30, 10, 3, 10, b => true).OrderByDescending(b => b.NumPeaks).First();
Assert.IsTrue(Math.Abs(262.64 - sdafaf.Mass.ToMz(2)) <= 0.01);
using (ThermoDynamicData dynamicThermo = ThermoDynamicData.InitiateDynamicConnection(@"05-13-16_cali_MS_60K-res_MS.raw"))
{
Assert.AreEqual(136, dynamicThermo.GetClosestOneBasedSpectrumNumber(1.89));
dynamicThermo.ClearCachedScans();
}
Mzml readCovertedMzmlFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, "convertedThermo.mzML"));
Assert.AreEqual(a.GetAllScansList().First().Polarity, readCovertedMzmlFile.GetAllScansList().First().Polarity);
}
public static void TestFlashLFQWithPassedFile()
{
// read periodic table - needed to open the raw files
PeriodicTableLoader.Load(Path.Combine(TestContext.CurrentContext.TestDirectory, @"elements.dat"));
// get the raw files
string rawPath = Path.Combine(TestContext.CurrentContext.TestDirectory, @"sliced-raw.raw");
string mzmlPath = Path.Combine(TestContext.CurrentContext.TestDirectory, @"sliced-mzml.mzml");
var rawFile = ThermoDynamicData.InitiateDynamicConnection(rawPath);
var mzmlFile = Mzml.LoadAllStaticData(mzmlPath);
RawFileInfo raw = new RawFileInfo(rawPath, rawFile);
RawFileInfo mzml = new RawFileInfo(mzmlPath, mzmlFile);
// create some PSMs
Identification id1 = new Identification(raw, "EGFQVADGPLYR", "EGFQVADGPLYR", 1350.65681, 94.12193, 2, new List <string> {
"MyProtein"
});
Identification id2 = new Identification(raw, "EGFQVADGPLYR", "EGFQVADGPLYR", 1350.65681, 94.05811, 2, new List <string> {
"MyProtein"
});
Identification id3 = new Identification(mzml, "EGFQVADGPLYR", "EGFQVADGPLYR", 1350.65681, 94.12193, 2, new List <string> {
"MyProtein"
});
Identification id4 = new Identification(mzml, "EGFQVADGPLYR", "EGFQVADGPLYR", 1350.65681, 94.05811, 2, new List <string> {
"MyProtein"
});
// create the FlashLFQ engine
FlashLFQEngine engine = new FlashLFQEngine(new List <Identification> {
id1, id2, id3, id4
});
// run the engine
var results = engine.Run();
// check raw results
Assert.That(results.peaks[raw].Count == 1);
Assert.That(results.peaks[raw].First().intensity > 0);
Assert.That(!results.peaks[raw].First().isMbrFeature);
Assert.That(results.peptideBaseSequences["EGFQVADGPLYR"].intensities[raw] > 0);
Assert.That(results.peptideModifiedSequences["EGFQVADGPLYR"].intensities[raw] > 0);
Assert.That(results.proteinGroups["MyProtein"].intensities[raw] > 0);
// check mzml results
Assert.That(results.peaks[mzml].Count == 1);
Assert.That(results.peaks[mzml].First().intensity > 0);
Assert.That(!results.peaks[mzml].First().isMbrFeature);
Assert.That(results.peptideBaseSequences["EGFQVADGPLYR"].intensities[mzml] > 0);
Assert.That(results.peptideModifiedSequences["EGFQVADGPLYR"].intensities[mzml] > 0);
Assert.That(results.proteinGroups["MyProtein"].intensities[mzml] > 0);
// test peak output
List <string> output = new List <string>()
{
FlashLFQ.ChromatographicPeak.TabSeparatedHeader
};
foreach (var peak in results.peaks.SelectMany(p => p.Value))
{
output.Add(peak.ToString());
}
Assert.That(output.Count == 3);
// test peptide base sequence output
output = new List <string>()
{
Peptide.TabSeparatedHeader
};
foreach (var pep in results.peptideBaseSequences)
{
output.Add(pep.Value.ToString());
}
Assert.That(output.Count == 2);
// test peptide mod sequence output
output = new List <string>()
{
Peptide.TabSeparatedHeader
};
foreach (var pep in results.peptideModifiedSequences)
{
output.Add(pep.Value.ToString());
}
Assert.That(output.Count == 2);
// test protein output
output = new List <string>()
{
ProteinGroup.TabSeparatedHeader
};
foreach (var protein in results.proteinGroups)
{
output.Add(protein.Value.ToString());
}
Assert.That(output.Count == 2);
}
public bool IndexMassSpectralPeaks(SpectraFileInfo fileInfo, bool silent, Dictionary <SpectraFileInfo, Ms1ScanInfo[]> _ms1Scans)
{
if (!silent)
{
Console.WriteLine("Reading spectra file");
}
MsDataScan[] msDataScans = null;
// read spectra file
var ext = Path.GetExtension(fileInfo.FullFilePathWithExtension).ToUpperInvariant();
if (ext == ".MZML")
{
try
{
msDataScans = Mzml.LoadAllStaticData(fileInfo.FullFilePathWithExtension).GetAllScansList()
.OrderBy(p => p.OneBasedScanNumber).ToArray();
}
catch (FileNotFoundException)
{
if (!silent)
{
Console.WriteLine("\nCan't find .mzML file" + fileInfo.FullFilePathWithExtension + "\n");
}
return(false);
}
catch (Exception e)
{
if (!silent)
{
Console.WriteLine("Problem opening .mzML file " + fileInfo.FullFilePathWithExtension + "; " +
e.Message);
}
return(false);
}
for (int i = 0; i < msDataScans.Length; i++)
{
if (msDataScans[i].MsnOrder > 1)
{
msDataScans[i] = null;
}
}
}
else if (ext == ".RAW")
{
var tempList = new List <MsDataScan>();
ThermoDynamicData dynamicConnection = null;
try
{
dynamicConnection = new ThermoDynamicData(fileInfo.FullFilePathWithExtension);
// use thermo dynamic connection to get the ms1 scans and then dispose of the connection
for (int i = 0; i < dynamicConnection.MsOrdersByScan.Length; i++)
{
if (dynamicConnection.MsOrdersByScan[i] == 1)
{
tempList.Add(dynamicConnection.GetOneBasedScanFromDynamicConnection(i + 1));
}
else
{
tempList.Add(null);
}
}
dynamicConnection.CloseDynamicConnection();
}
catch (FileNotFoundException)
{
if (dynamicConnection != null)
{
dynamicConnection.CloseDynamicConnection();
}
if (!silent)
{
Console.WriteLine("\nCan't find .raw file" + fileInfo.FullFilePathWithExtension + "\n");
}
return(false);
}
catch (Exception e)
{
if (dynamicConnection != null)
{
dynamicConnection.CloseDynamicConnection();
}
if (!silent)
{
throw new MzLibException("FlashLFQ Error: Problem opening .raw file " + fileInfo.FullFilePathWithExtension + "; " + e.Message);
}
}
msDataScans = tempList.ToArray();
}
else
{
if (!silent)
{
Console.WriteLine("Unsupported file type " + ext);
return(false);
}
}
if (!silent)
{
Console.WriteLine("Indexing MS1 peaks");
}
if (!msDataScans.Any(p => p != null))
{
_indexedPeaks = new List <IndexedMassSpectralPeak> [0];
return(false);
}
_indexedPeaks = new List <IndexedMassSpectralPeak> [(int)Math.Ceiling(msDataScans.Where(p => p != null &&
p.MassSpectrum.LastX != null).Max(p => p.MassSpectrum.LastX.Value) * BinsPerDalton) + 1];
int scanIndex = 0;
List <Ms1ScanInfo> scanInfo = new List <Ms1ScanInfo>();
for (int i = 0; i < msDataScans.Length; i++)
{
if (msDataScans[i] == null)
{
continue;
}
scanInfo.Add(new Ms1ScanInfo(msDataScans[i].OneBasedScanNumber, scanIndex, msDataScans[i].RetentionTime));
for (int j = 0; j < msDataScans[i].MassSpectrum.XArray.Length; j++)
{
int roundedMz = (int)Math.Round(msDataScans[i].MassSpectrum.XArray[j] * BinsPerDalton, 0);
if (_indexedPeaks[roundedMz] == null)
{
_indexedPeaks[roundedMz] = new List <IndexedMassSpectralPeak>();
}
_indexedPeaks[roundedMz].Add(new IndexedMassSpectralPeak(msDataScans[i].MassSpectrum.XArray[j],
msDataScans[i].MassSpectrum.YArray[j], scanIndex, msDataScans[i].RetentionTime));
}
scanIndex++;
}
_ms1Scans.Add(fileInfo, scanInfo.ToArray());
if (_indexedPeaks == null || _indexedPeaks.Length == 0)
{
if (!silent)
{
Console.WriteLine("FlashLFQ Error: The file " + fileInfo.FilenameWithoutExtension + " contained no MS1 peaks!");
}
return(false);
}
return(true);
}
