public bool Validate() { // Check for folder-type datasets, and replace specFilePath with the directory name if it is. SourcePath = MassSpecDataReaderFactory.GetDatasetName(SourcePath); var isDirectoryDataset = MassSpecDataReaderFactory.IsADirectoryDataset(SourcePath); // True if specFilePath is a directory that is NOT a supported folder-type dataset. var specPathIsDirectory = Directory.Exists(SourcePath) && !isDirectoryDataset; if (!File.Exists(SourcePath) && !specPathIsDirectory && !isDirectoryDataset) { PrintError("File not found: " + SourcePath); return(false); } var types = MassSpecDataReaderFactory.MassSpecDataTypeFilterList; types.Remove(".pbf"); if (!specPathIsDirectory && !(types.Select(ext => SourcePath.ToLower().EndsWith(ext)).Any())) { PrintError("Invalid file extension: (" + Path.GetExtension(SourcePath) + ") " + SourcePath); return(false); } if (string.IsNullOrWhiteSpace(OutputDir)) { // 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 = specPathIsDirectory ? SourcePath : Path.GetDirectoryName(Path.GetFullPath(SourcePath)); } if (string.IsNullOrWhiteSpace(OutputDir)) { PrintError("Invalid output file directory: " + OutputDir); return(false); } if (EndScan < StartScan && EndScan > -1) { PrintError($"End scan ({EndScan}) must not be less than start scan ({StartScan})!"); return(false); } if (!Directory.Exists(OutputDir)) { if (File.Exists(OutputDir) && !File.GetAttributes(OutputDir).HasFlag(FileAttributes.Directory)) { PrintError("OutputDir \"" + OutputDir + "\" is not a directory!"); return(false); } Directory.CreateDirectory(OutputDir); } return(true); }
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 }
public bool Validate() { // Spec file path validation if (string.IsNullOrWhiteSpace(SpecFilePath)) { PrintError("Missing parameter for spectrum file path"); return(false); } // 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) { PrintError("File not found: " + SpecFilePath); return(false); } var types = MassSpecDataReaderFactory.MassSpecDataTypeFilterList; if (!specPathIsDirectory && !(types.Select(ext => SpecFilePath.ToLower().EndsWith(ext)).Any())) { PrintError("Invalid file extension for spectrum file: (" + Path.GetExtension(SpecFilePath) + ") " + SpecFilePath); return(false); } // TODO: Handle non-.raw files in the subfolder SpecFilePaths = Directory.Exists(SpecFilePath) && !MassSpecDataReaderFactory.IsADirectoryDataset(SpecFilePath) ? Directory.GetFiles(SpecFilePath, "*.raw") : new[] { SpecFilePath }; // Database path validation if (string.IsNullOrWhiteSpace(DatabaseFilePath)) { PrintError("Missing parameter for database file path"); return(false); } if (!File.Exists(DatabaseFilePath)) { PrintError("File not found: " + DatabaseFilePath); return(false); } var dbExtension = Path.GetExtension(DatabaseFilePath).ToLower(); if (!dbExtension.Equals(".fa") && !dbExtension.Equals(".fasta")) { PrintError("Invalid extension for the database file path (" + dbExtension + ")"); return(false); } // Output directory validation if (string.IsNullOrWhiteSpace(OutputDir)) { // 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 = specPathIsDirectory ? SpecFilePath : Path.GetDirectoryName(Path.GetFullPath(SpecFilePath)); } if (string.IsNullOrWhiteSpace(OutputDir)) { PrintError("Invalid output file directory: " + OutputDir); return(false); } if (!Directory.Exists(OutputDir)) { if (File.Exists(OutputDir) && !File.GetAttributes(OutputDir).HasFlag(FileAttributes.Directory)) { PrintError("OutputDir \"" + OutputDir + "\" is not a directory!"); return(false); } Directory.CreateDirectory(OutputDir); } // Mods file validation if (!string.IsNullOrWhiteSpace(ModsFilePath) && !File.Exists(ModsFilePath)) { PrintError("Modifications file not found: " + ModsFilePath); return(false); } try { var errorMessage = LoadModsFile(ModsFilePath); if (!string.IsNullOrWhiteSpace(errorMessage)) { PrintError(errorMessage); return(false); } } catch (Exception ex) { PrintError("Exception parsing the file for parameter -mod: " + ex.Message); return(false); } // Scans file validation if (!string.IsNullOrWhiteSpace(ScansFilePath) && !File.Exists(ScansFilePath)) { PrintError("Scans File file not found: " + ScansFilePath); return(false); } try { var errorMessage = LoadScansFile(ScansFilePath); if (!string.IsNullOrWhiteSpace(errorMessage)) { PrintError(errorMessage); return(false); } } catch (Exception ex) { PrintError("Exception parsing the file for parameter -scansFile: " + ex.Message); return(false); } // Feature file validation if (!string.IsNullOrWhiteSpace(FeatureFilePath) && !File.Exists(FeatureFilePath)) { PrintError("Feature File not found: " + FeatureFilePath); return(false); } if (!string.IsNullOrWhiteSpace(FeatureFilePath) && !Path.GetExtension(FeatureFilePath).ToLower().Equals(".csv") && !Path.GetExtension(FeatureFilePath).ToLower().Equals(".ms1ft") && !Path.GetExtension(FeatureFilePath).ToLower().Equals(".msalign")) { PrintError("Invalid extension for the Feature file path (" + Path.GetExtension(FeatureFilePath) + ")"); return(false); } // MinX/MaxX validation if (MinSequenceLength > MaxSequenceLength) { PrintError("MinPrecursorCharge (" + MinPrecursorIonCharge + ") is larger than MaxPrecursorCharge (" + MaxPrecursorIonCharge + ")!"); return(false); } if (MinProductIonCharge > MaxProductIonCharge) { PrintError("MinFragmentCharge (" + MinProductIonCharge + ") is larger than MaxFragmentCharge (" + MaxProductIonCharge + ")!"); return(false); } if (MinSequenceMass > MaxSequenceMass) { PrintError("MinSequenceMassInDa (" + MinSequenceMass + ") is larger than MaxSequenceMassInDa (" + MaxSequenceMass + ")!"); return(false); } MaxNumThreads = GetOptimalMaxThreads(MaxNumThreads); return(true); }