/// <summary> /// Look for the default .pbf testing file in the default test file folder, /// plus also in the UnitTest_Files directory in this project or solution /// </summary> /// <param name="createIfMissing">If true and the .mzML file is ofund, create the .pbf file</param> /// <returns>Path to the file if found, otherwise the default path on Proto-2</returns> public static string GetPbfTestFilePath(bool createIfMissing) { var methodName = MethodBase.GetCurrentMethod().Name; var pbfFilePath = Path.Combine(DEFAULT_SPEC_FILES_FOLDER, PBF_TEST_FILE); var pbfFileInfo = GetTestFile("PbfTestFilePath", pbfFilePath, false); if (pbfFileInfo != null) { // Check for a lock file, which would indicate another process is creating the .pbf file var existingLockFile = new FileInfo(Path.Combine(pbfFileInfo.FullName + ".lock")); WaitForLockFile(existingLockFile, false); pbfFileInfo.Refresh(); if (pbfFileInfo.Exists) { DeleteLockFile(existingLockFile); return(pbfFileInfo.FullName); } } if (!createIfMissing) { // Not creating the file if missing; return the default path, despite the fact that the file does not exist // The calling method will discover that the file is missing and act accordingly return(pbfFilePath); } // Create the missing file var mzmlFilePath = Path.Combine(DEFAULT_SPEC_FILES_FOLDER, MZML_TEST_FILE); var mzmlFileInfo = GetTestFile("MzmlTestFilePath", mzmlFilePath, false); if (mzmlFileInfo?.DirectoryName == null) { // Unable to create the pbf file; return the default path, despite the fact that the file does not exist return(pbfFilePath); } ShowMessage(methodName, string.Format("Creating {0} using {1}", PBF_TEST_FILE, mzmlFileInfo.FullName)); var lockFile = new FileInfo(Path.Combine(mzmlFileInfo.DirectoryName, Path.GetFileNameWithoutExtension(mzmlFileInfo.Name) + ".pbf.lock")); var newPbfFilePath = Path.Combine(mzmlFileInfo.DirectoryName, PBF_TEST_FILE); try { // Create a new lock file so other processes know this thread is creating the .pbf file WaitForLockFile(lockFile, true); mLastStatus = string.Empty; var startTime = DateTime.UtcNow; var reader = MassSpecDataReaderFactory.GetMassSpecDataReader(mzmlFileInfo.FullName); var progress = new Progress <ProgressData>(p => { p.UpdateFrequencySeconds = 2; if (p.Percent < 100 && (p.Percent % 25).Equals(0) || p.ShouldUpdate()) { var statusMessage = string.Format("{0}, {1:00.0}% complete ", p.Status, p.Percent); if (string.Equals(mLastStatus, statusMessage)) { return; } mLastStatus = statusMessage; Console.Write("\r{0}, {1:00.0}% complete ", p.Status, p.Percent); } }); var run = new PbfLcMsRun(mzmlFileInfo.FullName, reader, newPbfFilePath, 0, 0, progress); Console.WriteLine(); ShowMessage(methodName, string.Format("Created {0} in {1:F0} seconds", run.PbfFilePath, DateTime.UtcNow.Subtract(startTime).TotalSeconds)); DeleteLockFile(lockFile); return(run.PbfFilePath); } catch (Exception ex) { ShowMessage(methodName, string.Format("Exception creating {0} using {1}: {2}", PBF_TEST_FILE, mzmlFileInfo.FullName, ex.Message)); try { var incompletePbfFile = new FileInfo(newPbfFilePath); if (incompletePbfFile.Exists) { incompletePbfFile.Delete(); } DeleteLockFile(lockFile); } catch { // Ignore errors here } // Return the default path, despite the fact that the file does not exist return(pbfFilePath); } }
public static int Main(string[] args) { PbfGenInputParameters options; try { var osVersionInfo = new clsOSVersionInfo(); if (osVersionInfo.GetOSVersion().ToLower().Contains("windows")) { var handle = Process.GetCurrentProcess().MainWindowHandle; SetConsoleMode(handle, EnableExtendedFlags); } var exeName = System.Reflection.Assembly.GetEntryAssembly().GetName().Name; var parser = new CommandLineParser <PbfGenInputParameters>(exeName, Version); parser.UsageExamples.Add($"Using -start and -end to limit the scan range to include in the .pbf file\n\t{exeName}.exe -s Dataset.raw -start 2000 -end 3000"); var results = parser.ParseArgs(args); if (!results.Success) { // Wait for 1.5 seconds System.Threading.Thread.Sleep(1500); return(-1); } if (!results.ParsedResults.Validate()) { parser.PrintHelp(); // Wait for 1.5 seconds System.Threading.Thread.Sleep(1500); return(-1); } options = results.ParsedResults; } catch (Exception ex) { Console.WriteLine("Exception while parsing the command line parameters: " + ex.Message); return(-5); } #if (!DEBUG) try #endif { var specFilePaths = new[] { options.SourcePath }; if (Directory.Exists(options.SourcePath) && !MassSpecDataReaderFactory.IsADirectoryDataset(options.SourcePath)) { specFilePaths = Directory.GetFiles(options.SourcePath, "*.raw"); // TODO: Support folders with other formats in them too... } foreach (var rawFilePath in specFilePaths) { var pbfFileName = MassSpecDataReaderFactory.ChangeExtension(rawFilePath, PbfLcMsRun.FileExtensionConst); var pbfFilePath = Path.Combine(options.OutputDir, Path.GetFileName(pbfFileName)); if (File.Exists(pbfFilePath) && PbfLcMsRun.CheckFileFormatVersion(pbfFilePath, out var isCurrent) && isCurrent) { Console.WriteLine("{0} already exists.", pbfFilePath); continue; } Console.WriteLine("Creating {0} from {1}", pbfFilePath, rawFilePath); if (options.StartScan > 0 && options.EndScan > 0) { Console.WriteLine("Only including scans {0} to {1}", options.StartScan, options.EndScan); } else if (options.StartScan > 0) { Console.WriteLine("Only including scans {0} to the end", options.StartScan); } else if (options.EndScan > 0) { Console.WriteLine("Only including scans 1 to {0}", options.EndScan); } var reader = MassSpecDataReaderFactory.GetMassSpecDataReader(rawFilePath); var progress = new Progress <ProgressData>(p => { p.UpdateFrequencySeconds = 2; if ((p.Percent % 25).Equals(0) || p.ShouldUpdate()) { Console.Write("\r{0}, {1:00.0}% complete ", p.Status, p.Percent); } }); var run = new PbfLcMsRun(rawFilePath, reader, pbfFilePath, 0, 0, progress, false, options.StartScan, options.EndScan); Console.WriteLine(); } Console.WriteLine("PbfFormatVersion: {0}", PbfLcMsRun.FileFormatId); return(0); } #if (!DEBUG) catch (Exception ex) { // NOTE: The DMS Analysis Manager looks for this text; do not change it Console.WriteLine("Exception while processing: " + ex.Message); Console.WriteLine(ex.StackTrace); var errorCode = -Math.Abs(ex.Message.GetHashCode()); if (errorCode == 0) { return(-1); } else { return(errorCode); } } #endif }
public void TestReadingPbfFile() { var methodName = MethodBase.GetCurrentMethod().Name; Utils.ShowStarting(methodName); var pbfFilePath = Path.Combine(Utils.DEFAULT_TEST_FILE_FOLDER, @"TopDown\ProductionQCShew\QC_Shew_13_04_A_17Feb14_Samwise_13-07-28.pbf"); if (!File.Exists(pbfFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, pbfFilePath); } var pbfRun = new PbfLcMsRun(pbfFilePath); var checksum = pbfRun.PbfFileChecksum; var specFilePath = Path.ChangeExtension(pbfFilePath, "raw"); if (!File.Exists(specFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, specFilePath); } Console.WriteLine(@"Loading .pbf into memory"); //var run = InMemoryLcMsRun.GetLcMsRun(specFilePath); var run = new InMemoryLcMsRun(MassSpecDataReaderFactory.GetMassSpecDataReader(specFilePath), 0, 0); Console.WriteLine(@"Comparing spectra between .pbf and in-memory spectra"); // spectrum comparison //for (var scanNum = run.MinLcScan; scanNum <= run.MaxLcScan; scanNum++) foreach (var scanNum in run.AllScanNumbers) { var spec1 = run.GetSpectrum(scanNum); var spec2 = pbfRun.GetSpectrum(scanNum); Assert.IsTrue(spec1.Peaks.Length == spec2.Peaks.Length); for (var i = 0; i < spec1.Peaks.Length; i++) { var p1 = spec1.Peaks[i]; var p2 = spec2.Peaks[i]; Assert.True(p1.Equals(p2)); Assert.True(Math.Abs(p1.Mz - p2.Mz) < 1e-8); Assert.True(Math.Abs(p1.Intensity - p2.Intensity) < 0.001); } } Console.WriteLine(@"Comparing XICs"); // chromatogram comparison const double targetMz = 655.01; var tolerance = new Tolerance(10); var xic1 = run.GetFullPrecursorIonExtractedIonChromatogram(targetMz, tolerance); var xic2 = pbfRun.GetFullPrecursorIonExtractedIonChromatogram(targetMz, tolerance); Assert.True(xic1.Count == xic2.Count); for (var i = 0; i < xic1.Count; i++) { if (!xic1[i].Equals(xic2[i])) { Console.WriteLine(@"{0} {1} {2}", i, xic1[i], xic2[i]); } Assert.True(xic1[i].Equals(xic2[i])); } Console.WriteLine(@"Done"); }
public static int Main(string[] args) { string specFilePath; string outputDir; try { var handle = Process.GetCurrentProcess().MainWindowHandle; SetConsoleMode(handle, EnableExtendedFlags); if (args.Length == 0) { PrintUsageInfo(); return(-1); } var paramDic = new Dictionary <string, string> { { "-s", null }, { "-o", null } }; for (var i = 0; i < args.Length / 2; i++) { var key = args[2 * i]; var value = args[2 * i + 1]; if (!paramDic.ContainsKey(key)) { PrintUsageInfo("Invalid parameter: " + key); return(-1); } paramDic[key] = value; } // Parse command line parameters specFilePath = paramDic["-s"]; if (specFilePath == null) { PrintUsageInfo("Missing required parameter -s!"); return(-1); } // Check for folder-type datasets, and replace specFilePath with the directory name if it is. specFilePath = MassSpecDataReaderFactory.GetDatasetName(specFilePath); var isDirectoryDataset = MassSpecDataReaderFactory.IsADirectoryDataset(specFilePath); // True if specFilePath is a directory that is NOT a supported folder-type dataset. var specPathIsDirectory = Directory.Exists(specFilePath) && !isDirectoryDataset; if (!File.Exists(specFilePath) && !specPathIsDirectory && !isDirectoryDataset) { PrintUsageInfo("File not found: " + specFilePath); return(-1); } var types = MassSpecDataReaderFactory.MassSpecDataTypeFilterList; types.Remove(".pbf"); if (!specPathIsDirectory && !(types.Select(ext => specFilePath.ToLower().EndsWith(ext)).Any())) { PrintUsageInfo("Invalid file extension: (" + Path.GetExtension(specFilePath) + ") " + specFilePath); return(-1); } // Must use "Path.GetFullPath" to return the absolute path when the source file is in the working directory // But, it could cause problems with too-long paths. outputDir = paramDic["-o"] ?? (specPathIsDirectory ? specFilePath : Path.GetDirectoryName(Path.GetFullPath(specFilePath))); if (outputDir == null) { PrintUsageInfo("Invalid output file directory: " + specFilePath); return(-1); } if (!Directory.Exists(outputDir)) { if (File.Exists(outputDir) && !File.GetAttributes(outputDir).HasFlag(FileAttributes.Directory)) { PrintUsageInfo("OutputDir " + outputDir + " is not a directory!"); return(-1); } Directory.CreateDirectory(outputDir); } } catch (Exception ex) { Console.WriteLine("Exception while parsing the command line parameters: " + ex.Message); return(-5); } #if (!DEBUG) try { #endif string[] specFilePaths = new[] { specFilePath }; if (Directory.Exists(specFilePath) && !MassSpecDataReaderFactory.IsADirectoryDataset(specFilePath)) { specFilePaths = Directory.GetFiles(specFilePath, "*.raw"); } foreach (var rawFilePath in specFilePaths) { var pbfFilePath = Path.Combine(outputDir, Path.GetFileNameWithoutExtension(rawFilePath) + PbfLcMsRun.FileExtension); bool isCurrent; if (File.Exists(pbfFilePath) && PbfLcMsRun.CheckFileFormatVersion(pbfFilePath, out isCurrent) && isCurrent) { Console.WriteLine("{0} already exists.", pbfFilePath); continue; } Console.WriteLine("Creating {0} from {1}", pbfFilePath, rawFilePath); IMassSpecDataReader reader = MassSpecDataReaderFactory.GetMassSpecDataReader(rawFilePath); var progress = new Progress <ProgressData>(p => { p.UpdateFrequencySeconds = 2; if ((p.Percent % 25).Equals(0) || p.ShouldUpdate()) { Console.Write("\r{0}, {1:00.0}% complete ", p.Status, p.Percent); } }); var run = new PbfLcMsRun(rawFilePath, reader, pbfFilePath, 0, 0, progress); Console.WriteLine(); } Console.WriteLine("PbfFormatVersion: {0}", PbfLcMsRun.FileFormatId); return(0); #if (!DEBUG) } catch (Exception ex) { // NOTE: The DMS Analysis Manager looks for this text; do not change it Console.WriteLine("Exception while processing: " + ex.Message); Console.WriteLine(ex.StackTrace); var errorCode = -Math.Abs(ex.Message.GetHashCode()); if (errorCode == 0) { return(-1); } else { return(errorCode); } } #endif }
/// <summary> /// Process spectra and identifications. /// </summary> /// <param name="rawFilePath">Full file path to raw file.</param> /// <param name="idFilePath">Full file path to identification file.</param> /// <param name="cancellationToken">For notification of cancellation.</param> /// <param name="progress">Progress reporter.</param> /// <returns>List of processed IDs.</returns> public List <ProcessedResult> Process(string rawFilePath, string idFilePath, CancellationToken cancellationToken, IProgress <ProgressData> progress = null) { // Set up progress reporter progress = progress ?? new Progress <ProgressData>(); var progressData = new ProgressData(progress); // Show initial loading message progressData.Report(0.1, "Loading..."); // Read mzid file var mzidReader = new SimpleMZIdentMLReader(); var identifications = mzidReader.Read(idFilePath, cancellationToken); // Check to make sure raw and MZID file match. var rawFileName = Path.GetFileNameWithoutExtension(rawFilePath); var spectrumFileFromId = Path.GetFileNameWithoutExtension(identifications.SpectrumFile); var dtaIndex = spectrumFileFromId.LastIndexOf("_dta"); if (dtaIndex >= 0) { spectrumFileFromId = spectrumFileFromId.Substring(0, dtaIndex); } if (rawFileName != spectrumFileFromId) { throw new ArgumentException($"Mismatch between spectrum file ({rawFileName}) and id file ({spectrumFileFromId})."); } // Group IDs into a hash by scan number var idMap = identifications.Identifications.GroupBy(id => id.ScanNum).ToDictionary(scan => scan.Key, ids => ids); var processedResults = new ConcurrentBag <ProcessedResult>(); // Load raw file using (var lcms = MassSpecDataReaderFactory.GetMassSpecDataReader(rawFilePath)) { int count = 0; Parallel.ForEach( lcms.ReadAllSpectra(), spectrum => { if (cancellationToken.IsCancellationRequested) { // Cancel if necessary return; } // Report completion percentage and current scan number if (count % (int)Math.Max(0.01 * lcms.NumSpectra, 1) == 0) { progressData.Report(count, lcms.NumSpectra, $"{Math.Round(100.0*count / lcms.NumSpectra)}%"); } Interlocked.Increment(ref count); // Skip spectrum if it isn't MS2 var productSpectrum = spectrum as ProductSpectrum; if (productSpectrum == null || !idMap.ContainsKey(spectrum.ScanNum)) { return; } var specResults = idMap[spectrum.ScanNum]; var results = from specResult in specResults let sequence = specResult.Peptide.GetIpSequence() let coverage = this.CalculateSequenceCoverage(productSpectrum, sequence, specResult.Charge) select new ProcessedResult { ScanNum = spectrum.ScanNum, Sequence = sequence, Charge = specResult.Charge, PrecursorMz = specResult.CalMz, DeNovoScore = specResult.DeNovoScore, SpecEValue = specResult.SpecEv, EValue = specResult.EValue, QValue = specResult.QValue, PepQValue = specResult.PepQValue, FragMethod = productSpectrum.ActivationMethod, IsotopeError = specResult.IsoError, SequenceCoverage = Math.Round(coverage), }; foreach (var result in results) { processedResults.Add(result); } }); } // Sort spectra by SpecEValue return(processedResults.OrderBy(pr => pr.SpecEValue).ToList()); }