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;
}
