public bool OpenSkyFile(string skylineFile) { try { var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); using (var stream = new StreamReaderWithProgress(skylineFile, progressMonitor)) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(SrmDocument)); _out.WriteLine(Resources.CommandLine_OpenSkyFile_Opening_file___); _doc = ConnectDocument((SrmDocument)xmlSerializer.Deserialize(stream), skylineFile); if (_doc == null) return false; _out.WriteLine(Resources.CommandLine_OpenSkyFile_File__0__opened_, Path.GetFileName(skylineFile)); } } catch (FileNotFoundException) { _out.WriteLine(Resources.CommandLine_OpenSkyFile_Error__The_Skyline_file__0__does_not_exist_, skylineFile); return false; } catch (Exception x) { _out.WriteLine(Resources.CommandLine_OpenSkyFile_Error__There_was_an_error_opening_the_file__0_, skylineFile); _out.WriteLine(XmlUtil.GetInvalidDataMessage(skylineFile, x)); return false; } _skylineFile = skylineFile; return true; }
public void Run(string[] args) { var commandArgs = new CommandArgs(_out, _doc != null); if(!commandArgs.ParseArgs(args)) { _out.WriteLine(Resources.CommandLine_Run_Exiting___); return; } // First come the commands that do not depend on an --in command to run. // These commands modify Settings.Default instead of working with an open skyline document. if (commandArgs.InstallingToolsFromZip) { ImportToolsFromZip(commandArgs.ZippedToolsPath, commandArgs.ResolveZipToolConflictsBySkipping, commandArgs.ResolveZipToolAnotationConflictsBySkipping, commandArgs.ZippedToolsProgramPathContainer, commandArgs.ZippedToolsProgramPathValue, commandArgs.ZippedToolsPackagesHandled ); } if (commandArgs.ImportingTool) { ImportTool(commandArgs.ToolName, commandArgs.ToolCommand, commandArgs.ToolArguments, commandArgs.ToolInitialDirectory, commandArgs.ToolReportTitle, commandArgs.ToolOutputToImmediateWindow, commandArgs.ResolveToolConflictsBySkipping); } if (commandArgs.RunningBatchCommands) { RunBatchCommands(commandArgs.BatchCommandsPath); } if (commandArgs.ImportingSkyr) { ImportSkyr(commandArgs.SkyrPath, commandArgs.ResolveSkyrConflictsBySkipping); } if (!commandArgs.RequiresSkylineDocument) { // Exit quietly because Run(args[]) ran sucessfully. No work with a skyline document was called for. return; } string skylineFile = commandArgs.SkylineFile; if ((skylineFile != null && !OpenSkyFile(skylineFile)) || (skylineFile == null && _doc == null)) { _out.WriteLine(Resources.CommandLine_Run_Exiting___); return; } if (commandArgs.FullScanSetting) { if (!SetFullScanSettings(commandArgs)) return; } if (commandArgs.SettingLibraryPath) { if (!SetLibrary(commandArgs.LibraryName, commandArgs.LibraryPath)) _out.WriteLine(Resources.CommandLine_Run_Not_setting_library_); } if (commandArgs.ImportingFasta && !commandArgs.ImportingSearch) { try { ImportFasta(commandArgs.FastaPath, commandArgs.KeepEmptyProteins); } catch (Exception x) { _out.WriteLine(Resources.CommandLine_Run_Error__Failed_importing_the_file__0____1_, commandArgs.FastaPath, x.Message); return; } } if (commandArgs.ImportingTransitionList) { try { if (!ImportTransitionList(commandArgs)) return; } catch (Exception x) { _out.WriteLine(Resources.CommandLine_Run_Error__Failed_importing_the_file__0____1_, commandArgs.TransitionListPath, x.Message); return; } } if (commandArgs.ImportingSearch) { if (!ImportSearch(commandArgs)) { return; } } if (commandArgs.RemovingResults && !commandArgs.RemoveBeforeDate.HasValue) { RemoveResults(null); } if (commandArgs.ImportingResults) { OptimizableRegression optimize = null; try { if (_doc != null) optimize = _doc.Settings.TransitionSettings.Prediction.GetOptimizeFunction(commandArgs.ImportOptimizeType); } catch (Exception x) { _out.WriteLine(Resources.CommandLine_Run_Error__Failed_to_get_optimization_function__0____1_, commandArgs.ImportOptimizeType, x.Message); } if (commandArgs.ImportingReplicateFile) { // If expected results are not imported successfully, terminate if (!ImportResultsFile(commandArgs.ReplicateFile.ChangeParameters(_doc, commandArgs.LockMassParameters), commandArgs.ReplicateName, commandArgs.ImportBeforeDate, commandArgs.ImportOnOrAfterDate, optimize, commandArgs.ImportAppend, commandArgs.ImportDisableJoining)) return; } else if(commandArgs.ImportingSourceDirectory) { // If expected results are not imported successfully, terminate if(!ImportResultsInDir(commandArgs.ImportSourceDirectory, commandArgs.ImportNamingPattern, commandArgs.LockMassParameters, commandArgs.ImportBeforeDate, commandArgs.ImportOnOrAfterDate, optimize, commandArgs.ImportDisableJoining)) return; } } if (_doc != null && !_doc.IsLoaded) { IProgressMonitor progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); using (var docContainer = new ResultsMemoryDocumentContainer(null, _skylineFile) { ProgressMonitor = progressMonitor }) { docContainer.SetDocument(_doc, null, true); _doc = docContainer.Document; } } if (commandArgs.RemovingResults && commandArgs.RemoveBeforeDate.HasValue) { RemoveResults(commandArgs.RemoveBeforeDate); } if (commandArgs.Reintegrating) { if (!ReintegratePeaks(commandArgs)) return; } if (commandArgs.Saving) { var saveFile = commandArgs.SaveFile ?? _skylineFile; if (!SaveFile(saveFile)) return; _skylineFile = saveFile; } if (commandArgs.ExportingReport) { ExportReport(commandArgs.ReportName, commandArgs.ReportFile, commandArgs.ReportColumnSeparator, commandArgs.IsReportInvariant); } if (commandArgs.ExportingChromatograms) { ExportChromatograms(commandArgs.ChromatogramsFile, commandArgs.ChromatogramsPrecursors, commandArgs.ChromatogramsProducts, commandArgs.ChromatogramsBasePeaks, commandArgs.ChromatogramsTics); } if (!string.IsNullOrEmpty(commandArgs.TransListInstrumentType) && !string.IsNullOrEmpty(commandArgs.MethodInstrumentType)) { _out.WriteLine(Resources.CommandLine_Run_Error__You_cannot_simultaneously_export_a_transition_list_and_a_method___Neither_will_be_exported__); } else { if (commandArgs.ExportingTransitionList) { ExportInstrumentFile(ExportFileType.List, commandArgs); } if (commandArgs.ExportingMethod) { ExportInstrumentFile(ExportFileType.Method, commandArgs); } } if (Document != null && Document.Settings.HasResults) { Document.Settings.MeasuredResults.ReadStreams.ForEach(s => s.CloseStream()); } if (commandArgs.SharingZipFile) { string sharedFileName; var sharedFileDir = Path.GetDirectoryName(_skylineFile) ?? string.Empty; if (!string.IsNullOrWhiteSpace(commandArgs.SharedFile)) { sharedFileName = Path.GetFileName(commandArgs.SharedFile.Trim()); if (!PathEx.HasExtension(sharedFileName, SrmDocumentSharing.EXT_SKY_ZIP)) { sharedFileName = Path.GetFileNameWithoutExtension(sharedFileName) + SrmDocumentSharing.EXT_SKY_ZIP; } var dir = Path.GetDirectoryName(commandArgs.SharedFile); sharedFileDir = string.IsNullOrEmpty(dir) ? sharedFileDir : dir; } else { sharedFileName = FileEx.GetTimeStampedFileName(_skylineFile); } var sharedFilePath = Path.Combine(sharedFileDir, sharedFileName); ShareDocument(_doc, _skylineFile, sharedFilePath, _out); } if (commandArgs.PublishingToPanorama) { // Publish the document to the given Panorama server if new results were added to the document // OR no results files were given on the command-line for importing to the document. if (_importCount > 0 || !commandArgs.ImportingResults) { // Publish document to the given folder on the Panorama Server var panoramaHelper = new PanoramaPublishHelper(_out); panoramaHelper.PublishToPanorama(commandArgs.PanoramaServer, _doc, _skylineFile, commandArgs.PanoramaFolder); } else { _out.WriteLine(Resources.CommandLine_Run_No_new_results_added__Skipping_Panorama_import_); } } }
public bool ImportResultsFile(MsDataFileUri replicateFile, string replicateName, DateTime? importBefore, DateTime? importOnOrAfter, OptimizableRegression optimize, bool disableJoining = false) { // Skip if file write time is after importBefore or before importAfter try { var fileLastWriteTime = replicateFile.GetFileLastWriteTime(); if (importBefore != null && importBefore < fileLastWriteTime) { _out.WriteLine(Resources.CommandLine_ImportResultsFile_File_write_date__0__is_after___import_before_date__1___Ignoring___, fileLastWriteTime, importBefore); return true; } else if (importOnOrAfter != null && importOnOrAfter >= fileLastWriteTime) { _out.WriteLine(Resources.CommandLine_ImportResultsFile_File_write_date__0__is_before___import_on_or_after_date__1___Ignoring___, fileLastWriteTime, importOnOrAfter); return true; } } catch (Exception e) { _out.WriteLine(Resources.CommandLine_ImportResultsInDir_Error__Could_not_get_last_write_time_for_file__0__, replicateFile); _out.WriteLine(e); return false; } _out.WriteLine(Resources.CommandLine_ImportResultsFile_Adding_results___); // Hack for un-readable RAW files from Thermo instruments. if(!CanReadFile(replicateFile)) { _out.WriteLine(Resources.CommandLine_ImportResultsFile_Warning__Cannot_read_file__0____Ignoring___, replicateFile); return true; } //This function will also detect whether the replicate exists in the document ProgressStatus status; SrmDocument newDoc; IProgressMonitor progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); try { if (disableJoining) _doc = _doc.ChangeSettingsNoDiff(_doc.Settings.ChangeIsResultsJoiningDisabled(true)); newDoc = ImportResults(_doc,_skylineFile, replicateName, replicateFile, optimize, progressMonitor, out status); } catch (Exception x) { _out.WriteLine(Resources.CommandLine_ImportResultsFile_Error__Failed_importing_the_results_file__0__, replicateFile); _out.WriteLine(x.Message); return false; } status = status ?? new ProgressStatus(string.Empty).Complete(); if (status.IsError && status.ErrorException != null) { if (status.ErrorException is MissingDataException) { _out.WriteLine(Resources.CommandLine_ImportResultsFile_Warning__Failed_importing_the_results_file__0____Ignoring___, replicateFile); _out.WriteLine(status.ErrorException.Message); return true; } _out.WriteLine(Resources.CommandLine_ImportResultsFile_Error__Failed_importing_the_results_file__0__, replicateFile); _out.WriteLine(status.ErrorException.Message); return false; } if (!status.IsComplete || ReferenceEquals(_doc, newDoc)) { _out.WriteLine(Resources.CommandLine_ImportResultsFile_Error__Failed_importing_the_results_file__0__, replicateFile); return false; } _doc = newDoc; _out.WriteLine(Resources.CommandLine_ImportResultsFile_Results_added_from__0__to_replicate__1__, replicateFile.GetFileName(), replicateName); //the file was imported successfully _importCount++; return true; }
public bool ImportResultsInDir(string sourceDir, Regex namingPattern, LockMassParameters lockMassParameters, DateTime? importBefore, DateTime? importOnOrAfter, OptimizableRegression optimize, bool disableJoining) { var listNamedPaths = GetDataSources(sourceDir, namingPattern); if (listNamedPaths == null) { return false; } bool hasMultiple = listNamedPaths.SelectMany(pair => pair.Key).Count() > 1; if (hasMultiple || disableJoining) { // Join at the end _doc = _doc.ChangeSettingsNoDiff(_doc.Settings.ChangeIsResultsJoiningDisabled(true)); } // Import files one at a time foreach (var namedPaths in listNamedPaths) { string replicateName = namedPaths.Key; var files = namedPaths.Value; foreach (var file in files) { if (!ImportResultsFile(file.ChangeParameters(_doc, lockMassParameters), replicateName, importBefore, importOnOrAfter, optimize)) return false; } } if (hasMultiple && !disableJoining) { // Allow joining to happen var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); using (var docContainer = new ResultsMemoryDocumentContainer(null, _skylineFile) { ProgressMonitor = progressMonitor }) { _doc = _doc.ChangeSettingsNoDiff(_doc.Settings.ChangeIsResultsJoiningDisabled(false)); if (!_doc.IsLoaded) { docContainer.SetDocument(_doc, null, true); _doc = docContainer.Document; // If not fully loaded now, there must have been an error. if (!_doc.IsLoaded) return false; } } } return true; }
public void ExportChromatograms(string chromatogramsFile, bool precursors, bool products, bool basePeaks, bool tics) { _out.WriteLine(Resources.CommandLine_ExportChromatograms_Exporting_chromatograms_file__0____, chromatogramsFile); var chromExtractors = new List<ChromExtractor>(); if (tics) chromExtractors.Add(ChromExtractor.summed); if (basePeaks) chromExtractors.Add(ChromExtractor.base_peak); var chromSources = new List<ChromSource>(); if (precursors) chromSources.Add(ChromSource.ms1); if (products) chromSources.Add(ChromSource.fragment); if (chromExtractors.Count == 0 && chromSources.Count == 0) { _out.WriteLine(Resources.CommandLine_ExportChromatograms_Error__At_least_one_chromatogram_type_must_be_selected); return; } var filesToExport = Document.Settings.HasResults ? Document.Settings.MeasuredResults.MSDataFilePaths.Select(f => f.GetFileName()).ToList() : new List<string>(); if (filesToExport.Count == 0) { _out.WriteLine(Resources.CommandLine_ExportChromatograms_Error__The_document_must_have_imported_results); return; } try { var chromExporter = new ChromatogramExporter(Document); using (var saver = new FileSaver(chromatogramsFile)) using (var writer = new StreamWriter(saver.SafeName)) { var status = new ProgressStatus(string.Empty); IProgressMonitor broker = new CommandProgressMonitor(_out, status); chromExporter.Export(writer, broker, filesToExport, LocalizationHelper.CurrentCulture, chromExtractors, chromSources); writer.Close(); broker.UpdateProgress(status.Complete()); saver.Commit(); _out.WriteLine(Resources.CommandLine_ExportChromatograms_Chromatograms_file__0__exported_successfully_, chromatogramsFile); } } catch (Exception x) { _out.WriteLine(Resources.CommandLine_ExportChromatograms_Error__Failure_attempting_to_save_chromatograms_file__0_, chromatogramsFile); _out.WriteLine(x.Message); } }
public void ImportFasta(string path, bool keepEmptyProteins) { _out.WriteLine(Resources.CommandLine_ImportFasta_Importing_FASTA_file__0____, Path.GetFileName(path)); using (var readerFasta = new StreamReader(path)) { var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); IdentityPath selectPath; long lines = Helpers.CountLinesInFile(path); int emptiesIgnored; _doc = _doc.ImportFasta(readerFasta, progressMonitor, lines, false, null, out selectPath, out emptiesIgnored); } // Remove all empty proteins unless otherwise specified if (!keepEmptyProteins) _doc = new RefinementSettings { MinPeptidesPerProtein = 1 }.Refine(_doc); }
public override void PerformLongExport(Action<IProgressMonitor> performExport) { var waitBroker = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); performExport(waitBroker); }
public static void SaveDocument(SrmDocument doc, string outFile, TextWriter outText) { // Make sure the containing directory is created string dirPath = Path.GetDirectoryName(outFile); if (dirPath != null) Directory.CreateDirectory(dirPath); var progressMonitor = new CommandProgressMonitor(outText, new ProgressStatus(string.Empty)); using (var saver = new FileSaver(outFile)) { saver.CheckException(); using (var writer = new XmlWriterWithProgress(saver.SafeName, outFile, Encoding.UTF8, doc.MoleculeTransitionCount, progressMonitor)) { XmlSerializer ser = new XmlSerializer(typeof(SrmDocument)); ser.Serialize(writer, doc); writer.Flush(); writer.Close(); saver.Commit(); var settings = doc.Settings; if (settings.HasResults) { if (settings.MeasuredResults.IsLoaded) { FileStreamManager fsm = FileStreamManager.Default; settings.MeasuredResults.OptimizeCache(outFile, fsm); //don't worry about updating the document with the results of optimization //as is done in SkylineFiles } } else { string cachePath = ChromatogramCache.FinalPathForName(outFile, null); FileEx.SafeDelete(cachePath, true); } } } }
private bool Reintegrate(ModelAndFeatures modelAndFeatures, bool isAnnotateScoring, bool isOverwritePeaks) { try { var resultsHandler = new MProphetResultsHandler(_doc, modelAndFeatures.ScoringModel, modelAndFeatures.Features) { OverrideManual = isOverwritePeaks, AddAnnotation = isAnnotateScoring, AddMAnnotation = isAnnotateScoring }; var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); resultsHandler.ScoreFeatures(progressMonitor); if (resultsHandler.IsMissingScores()) { _out.WriteLine(Resources.CommandLine_Reintegrate_Error__The_current_peak_scoring_model_is_incompatible_with_one_or_more_peptides_in_the_document__Please_train_a_new_model_); return false; } _doc = resultsHandler.ChangePeaks(progressMonitor); return true; } catch (Exception x) { _out.WriteLine(Resources.CommandLine_Reintegrate_Error__Failed_to_reintegrate_peaks_successfully_); _out.WriteLine(x.Message); return false; } }
private void PublishDocToPanorama(Server panoramaServer, string zipFilePath, string panoramaFolder) { var waitBroker = new CommandProgressMonitor(_statusWriter, new ProgressStatus(Resources.PanoramaPublishHelper_PublishDocToPanorama_Publishing_document_to_Panorama)); IPanoramaPublishClient publishClient = new WebPanoramaPublishClient(); try { publishClient.SendZipFile(panoramaServer, panoramaFolder, zipFilePath, waitBroker); } catch (Exception x) { var panoramaEx = x.InnerException as PanoramaImportErrorException ?? x as PanoramaImportErrorException; if (panoramaEx == null) { _statusWriter.WriteLine(Resources.PanoramaPublishHelper_PublishDocToPanorama_, x.Message); } else { _statusWriter.WriteLine( Resources.PanoramaPublishHelper_PublishDocToPanorama_An_error_occurred_on_the_Panorama_server___0___importing_the_file_, panoramaEx.ServerUrl); _statusWriter.WriteLine( Resources.PanoramaPublishHelper_PublishDocToPanorama_Error_details_can_be_found_at__0_, panoramaEx.JobUrl); } } }
private bool ImportTransitionList(CommandArgs commandArgs) { _out.WriteLine(Resources.CommandLine_ImportTransitionList_Importing_transiton_list__0____, Path.GetFileName(commandArgs.TransitionListPath)); IdentityPath selectPath; List<MeasuredRetentionTime> irtPeptides; List<SpectrumMzInfo> librarySpectra; List<TransitionImportErrorInfo> errorList; List<PeptideGroupDocNode> peptideGroups; var retentionTimeRegression = _doc.Settings.PeptideSettings.Prediction.RetentionTime; RCalcIrt calcIrt = retentionTimeRegression != null ? (retentionTimeRegression.Calculator as RCalcIrt) : null; var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty)); var inputs = new MassListInputs(commandArgs.TransitionListPath); var docNew = _doc.ImportMassList(inputs, progressMonitor, null, out selectPath, out irtPeptides, out librarySpectra, out errorList, out peptideGroups); // If nothing was imported (e.g. operation was canceled or zero error-free transitions) and also no errors, just return if (ReferenceEquals(docNew, _doc) && !errorList.Any()) return true; // Show the errors or as warnings, if error transitions are ignore if (errorList.Any()) { string messageFormat = !commandArgs.IsIgnoreTransitionErrors ? Resources.CommandLine_ImportTransitionList_Error___line__0___column__1____2_ : Resources.CommandLine_ImportTransitionList_Warning___line__0___column__1____2_; foreach (var errorMessage in errorList) { _out.WriteLine(messageFormat, errorMessage.Row, errorMessage.Column, errorMessage.ErrorMessage); } if (!commandArgs.IsIgnoreTransitionErrors) return false; } if (!commandArgs.IsTransitionListAssayLibrary) { _doc = docNew; return true; } if (irtPeptides.Count == 0 || librarySpectra.Count == 0) { if (irtPeptides.Any()) _out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__Imported_assay_library__0__lacks_ion_abundance_values_); else if (librarySpectra.Any()) _out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__Imported_assay_library__0__lacks_iRT_values_); else _out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__Imported_assay_library__0__lacks_iRT_and_ion_abundance_values_); return false; } string destinationPath = commandArgs.SaveFile ?? commandArgs.SkylineFile; string documentLibrary = BiblioSpecLiteSpec.GetLibraryFileName(destinationPath); // ReSharper disable once AssignNullToNotNullAttribute string outputLibraryPath = Path.Combine(Path.GetDirectoryName(documentLibrary), Path.GetFileNameWithoutExtension(documentLibrary) + BiblioSpecLiteSpec.ASSAY_NAME + BiblioSpecLiteSpec.EXT); bool libraryExists = File.Exists(outputLibraryPath); string libraryName = Path.GetFileNameWithoutExtension(destinationPath) + BiblioSpecLiteSpec.ASSAY_NAME; int indexOldLibrary = docNew.Settings.PeptideSettings.Libraries.LibrarySpecs.IndexOf( spec => spec != null && spec.FilePath == outputLibraryPath); bool libraryLinkedToDoc = indexOldLibrary != -1; if (libraryExists && !libraryLinkedToDoc) { _out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__There_is_an_existing_library_with_the_same_name__0__as_the_document_library_to_be_created_, libraryName); return false; } var dbIrtPeptides = irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, false, TimeSource.scan)).ToList(); var dbIrtPeptidesFilter = ImportAssayLibraryHelper.GetUnscoredIrtPeptides(dbIrtPeptides, calcIrt); // If there are no iRT peptides with different values than the database, don't import any iRT's bool checkPeptides = false; if (dbIrtPeptidesFilter.Any()) { if (calcIrt == null) { string irtDatabasePath = commandArgs.IrtDatabasePath; if (string.IsNullOrEmpty(irtDatabasePath)) irtDatabasePath = Path.ChangeExtension(destinationPath, IrtDb.EXT); if (!string.IsNullOrEmpty(commandArgs.IrtStandardsPath)) { _out.WriteLine(Resources.CommandLine_ImportTransitionList_Importing_iRT_transition_list__0_, commandArgs.IrtStandardsPath); var irtInputs = new MassListInputs(commandArgs.IrtStandardsPath); try { List<SpectrumMzInfo> irtLibrarySpectra; docNew = docNew.ImportMassList(irtInputs, null, out selectPath, out irtPeptides, out irtLibrarySpectra, out errorList); if (errorList.Any()) { throw new InvalidDataException(errorList[0].ErrorMessage); } librarySpectra.AddRange(irtLibrarySpectra); dbIrtPeptidesFilter.AddRange(irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, true, TimeSource.scan))); } catch (Exception x) { _out.WriteLine(Resources.CommandLine_Run_Error__Failed_importing_the_file__0____1_, commandArgs.IrtStandardsPath, x.Message); return false; } if (!CreateIrtDatabase(irtDatabasePath, commandArgs)) return false; } else if (!string.IsNullOrEmpty(commandArgs.IrtGroupName)) { var nodeGroupIrt = docNew.PeptideGroups.FirstOrDefault(nodeGroup => nodeGroup.Name == commandArgs.IrtGroupName); if (nodeGroupIrt == null) { _out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__The_name__0__specified_with__1__was_not_found_in_the_imported_assay_library_, commandArgs.IrtGroupName, CommandArgs.ArgText(CommandArgs.ARG_IRT_STANDARDS_GROUP_NAME)); return false; } var irtPeptideSequences = new HashSet<string>(nodeGroupIrt.Peptides.Select(pep => pep.ModifiedSequence)); dbIrtPeptidesFilter.ForEach(pep => pep.Standard = irtPeptideSequences.Contains(pep.PeptideModSeq)); if (!CreateIrtDatabase(irtDatabasePath, commandArgs)) return false; } else if (!File.Exists(irtDatabasePath)) { _out.Write(Resources.CommandLine_ImportTransitionList_Error__To_create_the_iRT_database___0___for_this_assay_library__you_must_specify_the_iRT_standards_using_either_of_the_arguments__1__or__2_, irtDatabasePath, CommandArgs.ArgText(CommandArgs.ARG_IRT_STANDARDS_GROUP_NAME), CommandArgs.ArgText(CommandArgs.ARG_IRT_STANDARDS_FILE)); return false; } else { checkPeptides = true; } string irtCalcName = commandArgs.IrtCalcName ?? Path.GetFileNameWithoutExtension(destinationPath); calcIrt = new RCalcIrt(irtCalcName, irtDatabasePath); retentionTimeRegression = new RetentionTimeRegression(calcIrt.Name, calcIrt, null, null, 10, new List<MeasuredRetentionTime>()); docNew = docNew.ChangeSettings(docNew.Settings.ChangePeptidePrediction(prediction => prediction.ChangeRetentionTime(retentionTimeRegression))); } string dbPath = calcIrt.DatabasePath; IrtDb db = IrtDb.GetIrtDb(dbPath, null); if (checkPeptides) { var standards = docNew.Molecules.Where(m => db.IsStandard(m.RawTextId)).ToArray(); if (standards.Length != db.StandardPeptideCount) { _out.WriteLine(Resources.CommandLine_ImportTransitionList_Warning__The_document_is_missing_iRT_standards); foreach (var rawTextId in db.StandardPeptides.Where(s => !standards.Contains(nodePep => s == nodePep.RawTextId))) { _out.WriteLine(" " + rawTextId); // Not L10N } } } var oldPeptides = db.GetPeptides().ToList(); IList<DbIrtPeptide.Conflict> conflicts; dbIrtPeptidesFilter = DbIrtPeptide.MakeUnique(dbIrtPeptidesFilter); DbIrtPeptide.FindNonConflicts(oldPeptides, dbIrtPeptidesFilter, null, out conflicts); // Warn about peptides that are present in the import and already in the database foreach (var conflict in conflicts) { _out.WriteLine(Resources.CommandLine_ImportTransitionList_Warning__The_iRT_calculator_already_contains__0__with_the_value__1___Ignoring__2_, conflict.ExistingPeptide.PeptideModSeq, conflict.ExistingPeptide.Irt, conflict.NewPeptide.Irt); } _out.WriteLine(Resources.CommandLine_ImportTransitionList_Importing__0__iRT_values_into_the_iRT_calculator__1_, dbIrtPeptidesFilter.Count, calcIrt.Name); docNew = docNew.AddIrtPeptides(dbIrtPeptidesFilter, false, progressMonitor); if (docNew == null) return false; } librarySpectra = SpectrumMzInfo.RemoveDuplicateSpectra(librarySpectra); if (libraryLinkedToDoc) { string oldName = docNew.Settings.PeptideSettings.Libraries.LibrarySpecs[indexOldLibrary].Name; var libraryOld = docNew.Settings.PeptideSettings.Libraries.GetLibrary(oldName); var additionalSpectra = SpectrumMzInfo.GetInfoFromLibrary(libraryOld); additionalSpectra = SpectrumMzInfo.RemoveDuplicateSpectra(additionalSpectra); librarySpectra = SpectrumMzInfo.MergeWithOverwrite(librarySpectra, additionalSpectra); foreach (var stream in libraryOld.ReadStreams) stream.CloseStream(); } if (librarySpectra.Any()) { // Delete the existing library; either it's not tied to the document or we've already extracted the spectra _out.WriteLine(Resources.CommandLine_ImportTransitionList_Adding__0__spectra_to_the_library__1_, librarySpectra.Count, libraryName); if (libraryExists) { FileEx.SafeDelete(outputLibraryPath); FileEx.SafeDelete(Path.ChangeExtension(outputLibraryPath, BiblioSpecLiteSpec.EXT_REDUNDANT)); } using (var blibDb = BlibDb.CreateBlibDb(outputLibraryPath)) { var docLibrarySpec = new BiblioSpecLiteSpec(libraryName, outputLibraryPath); var docLibrary = blibDb.CreateLibraryFromSpectra(docLibrarySpec, librarySpectra, libraryName, progressMonitor); if (docLibrary == null) return false; var newSettings = docNew.Settings.ChangePeptideLibraries( libs => libs.ChangeLibrary(docLibrary, docLibrarySpec, indexOldLibrary)); docNew = docNew.ChangeSettings(newSettings, new SrmSettingsChangeMonitor(progressMonitor, Resources.SkylineWindow_ImportMassList_Finishing_up_import)); } } _doc = docNew; return true; }
private bool ImportSearchInternal(CommandArgs commandArgs, ref SrmDocument doc) { var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(String.Empty)); var import = new ImportPeptideSearch { SearchFilenames = commandArgs.SearchResultsFiles.ToArray(), CutoffScore = commandArgs.CutoffScore.GetValueOrDefault() }; // Build library var builder = import.GetLibBuilder(doc, commandArgs.Saving ? commandArgs.SaveFile : commandArgs.SkylineFile, commandArgs.IncludeAmbiguousMatches); ImportPeptideSearch.ClosePeptideSearchLibraryStreams(doc); _out.WriteLine(Resources.CommandLine_ImportSearch_Creating_spectral_library_from_files_); foreach (var file in commandArgs.SearchResultsFiles) _out.WriteLine(Path.GetFileName(file)); if (!builder.BuildLibrary(progressMonitor)) return false; if (!string.IsNullOrEmpty(builder.AmbiguousMatchesMessage)) _out.WriteLine(builder.AmbiguousMatchesMessage); var docLibSpec = builder.LibrarySpec.ChangeDocumentLibrary(true); _out.WriteLine(Resources.CommandLine_ImportSearch_Loading_library); var libraryManager = new LibraryManager(); if (!import.LoadPeptideSearchLibrary(libraryManager, docLibSpec, progressMonitor)) return false; doc = import.AddDocumentSpectralLibrary(doc, docLibSpec); if (doc == null) return false; if (!import.VerifyRetentionTimes(import.GetFoundResultsFiles().Select(f => f.Path))) { _out.WriteLine(TextUtil.LineSeparate( Resources.ImportPeptideSearchDlg_NextPage_The_document_specific_spectral_library_does_not_have_valid_retention_times_, Resources.ImportPeptideSearchDlg_NextPage_Please_check_your_peptide_search_pipeline_or_contact_Skyline_support_to_ensure_retention_times_appear_in_your_spectral_libraries_)); return false; } // Look for results files to import import.InitializeSpectrumSourceFiles(doc); import.UpdateSpectrumSourceFilesFromDirs(import.GetDirsToSearch(Path.GetDirectoryName(commandArgs.SkylineFile)), false, null); var missingResultsFiles = import.GetMissingResultsFiles().ToArray(); if (missingResultsFiles.Any()) { foreach (var file in missingResultsFiles) { if (doc.Settings.HasResults && doc.Settings.MeasuredResults.FindMatchingMSDataFile(new MsDataFilePath(file)) != null) continue; _out.WriteLine(Resources.CommandLine_ImportSearch_Warning__Unable_to_locate_results_file___0__, Path.GetFileName(file)); } } // Add all modifications, if requested if (commandArgs.AcceptAllModifications) { import.InitializeModifications(doc); var foundMods = import.GetMatchedMods().Count(); var newModifications = new PeptideModifications(import.MatcherPepMods.StaticModifications, new[] {new TypedModifications(IsotopeLabelType.heavy, import.MatcherHeavyMods)}); var newSettings = import.AddModifications(doc, newModifications); if (!ReferenceEquals(doc.Settings, newSettings)) { if (foundMods != 1) _out.WriteLine(Resources.CommandLine_ImportSearch_Adding__0__modifications_, foundMods); else _out.WriteLine(Resources.CommandLine_ImportSearch_Adding_1_modification_); doc = doc.ChangeSettings(newSettings); doc.Settings.UpdateDefaultModifications(false); } } // Import FASTA if (commandArgs.ImportingFasta) { _out.WriteLine(Resources.CommandLine_ImportFasta_Importing_FASTA_file__0____, Path.GetFileName(commandArgs.FastaPath)); doc = ImportPeptideSearch.PrepareImportFasta(doc); int emptyProteins; try { IdentityPath firstAdded, nextAdd; doc = ImportPeptideSearch.ImportFasta(doc, commandArgs.FastaPath, progressMonitor, null, out firstAdded, out nextAdd, out emptyProteins); } catch (Exception x) { _out.WriteLine(Resources.CommandLine_Run_Error__Failed_importing_the_file__0____1_, commandArgs.FastaPath, x.Message); _doc = doc; return true; // So that document will be saved with the new library } if (emptyProteins > 0 && !commandArgs.KeepEmptyProteins) { doc = ImportPeptideSearch.RemoveEmptyProteins(doc); } } // Import results _doc = doc; ImportFoundResultsFiles(commandArgs, import); return true; }
private void ExportLiveReport(string reportName, string reportFile, char reportColSeparator, bool reportInvariant) { var viewContext = DocumentGridViewContext.CreateDocumentGridViewContext(_doc, reportInvariant ? DataSchemaLocalizer.INVARIANT : SkylineDataSchema.GetLocalizedSchemaLocalizer()); var viewInfo = viewContext.GetViewInfo(PersistedViews.MainGroup.Id.ViewName(reportName)); if (null == viewInfo) { _out.WriteLine(Resources.CommandLine_ExportLiveReport_Error__The_report__0__does_not_exist__If_it_has_spaces_in_its_name__use__double_quotes__around_the_entire_list_of_command_parameters_, reportName); return; } _out.WriteLine(Resources.CommandLine_ExportLiveReport_Exporting_report__0____, reportName); try { using (var saver = new FileSaver(reportFile)) { if (!saver.CanSave()) { _out.WriteLine(Resources.CommandLine_ExportLiveReport_Error__The_report__0__could_not_be_saved_to__1__, reportName, reportFile); _out.WriteLine(Resources.CommandLine_ExportLiveReport_Check_to_make_sure_it_is_not_read_only_); } var status = new ProgressStatus(string.Empty); IProgressMonitor broker = new CommandProgressMonitor(_out, status); using (var writer = new StreamWriter(saver.SafeName)) { viewContext.Export(broker, ref status, viewInfo, writer, new DsvWriter(reportInvariant ? CultureInfo.InvariantCulture : LocalizationHelper.CurrentCulture, reportColSeparator)); } broker.UpdateProgress(status.Complete()); saver.Commit(); _out.WriteLine(Resources.CommandLine_ExportLiveReport_Report__0__exported_successfully_to__1__, reportName, reportFile); } } catch (Exception x) { _out.WriteLine(Resources.CommandLine_ExportLiveReport_Error__Failure_attempting_to_save__0__report_to__1__, reportName, reportFile); _out.WriteLine(x.Message); } }
private ModelAndFeatures CreateScoringModel(string modelName, bool decoys, bool secondBest) { _out.WriteLine(Resources.CommandLine_CreateScoringModel_Creating_scoring_model__0_, modelName); try { // Create new scoring model using the default calculators. var scoringModel = new MProphetPeakScoringModel(modelName, null as LinearModelParams, null, decoys, secondBest); var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(String.Empty)); var targetDecoyGenerator = new TargetDecoyGenerator(_doc, scoringModel, progressMonitor); // Get scores for target and decoy groups. List<IList<float[]>> targetTransitionGroups; List<IList<float[]>> decoyTransitionGroups; targetDecoyGenerator.GetTransitionGroups(out targetTransitionGroups, out decoyTransitionGroups); // If decoy box is checked and no decoys, throw an error if (decoys && decoyTransitionGroups.Count == 0) { _out.WriteLine(Resources.CommandLine_CreateScoringModel_Error__There_are_no_decoy_peptides_in_the_document__Failed_to_create_scoring_model_); return null; } // Use decoys for training only if decoy box is checked if (!decoys) decoyTransitionGroups = new List<IList<float[]>>(); // Set intial weights based on previous model (with NaN's reset to 0) var initialWeights = new double[scoringModel.PeakFeatureCalculators.Count]; // But then set to NaN the weights that have unknown values for this dataset for (int i = 0; i < initialWeights.Length; ++i) { if (!targetDecoyGenerator.EligibleScores[i]) initialWeights[i] = double.NaN; } var initialParams = new LinearModelParams(initialWeights); // Train the model. scoringModel = (MProphetPeakScoringModel)scoringModel.Train(targetTransitionGroups, decoyTransitionGroups, initialParams, secondBest, true, progressMonitor); Settings.Default.PeakScoringModelList.SetValue(scoringModel); return new ModelAndFeatures(scoringModel, targetDecoyGenerator.PeakGroupFeatures); } catch (Exception x) { _out.WriteLine(Resources.CommandLine_CreateScoringModel_Error__Failed_to_create_scoring_model_); _out.WriteLine(x.Message); return null; } }
private static bool ShareDocument(SrmDocument document, string documentPath, string fileDest, CommandStatusWriter statusWriter) { var waitBroker = new CommandProgressMonitor(statusWriter, new ProgressStatus(Resources.SkylineWindow_ShareDocument_Compressing_Files)); var sharing = new SrmDocumentSharing(document, documentPath, fileDest, false); try { sharing.Share(waitBroker); return true; } catch (Exception x) { statusWriter.WriteLine(Resources.SkylineWindow_ShareDocument_Failed_attempting_to_create_sharing_file__0__, fileDest); statusWriter.WriteLine(x.Message); } return false; }