public bool CreateIrtDatabase(string irtDatabasePath, CommandArgs commandArgs)
{
if (File.Exists(irtDatabasePath))
{
_out.WriteLine(Resources.CommandLine_CreateIrtDatabase_Error__Importing_an_assay_library_to_a_document_without_an_iRT_calculator_cannot_create__0___because_it_exists_,
irtDatabasePath);
if (string.IsNullOrEmpty(commandArgs.IrtDatabasePath))
{
_out.WriteLine(Resources.CommandLine_CreateIrtDatabase_Use_the__0__argument_to_specify_a_file_to_create_, CommandArgs.ArgText(CommandArgs.ARG_IRT_DATABASE_PATH));
}
return false;
}
try
{
ImportAssayLibraryHelper.CreateIrtDatabase(irtDatabasePath);
}
catch (Exception x)
{
_out.WriteLine(Resources.CommandLine_GeneralException_Error___0_, x);
return false;
}
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_);
}
}
}
private bool ReintegratePeaks(CommandArgs commandArgs)
{
if (!_doc.Settings.HasResults)
{
_out.WriteLine(Resources.CommandLine_ReintegratePeaks_Error__You_must_first_import_results_into_the_document_before_reintegrating_);
return false;
}
else
{
ModelAndFeatures modelAndFeatures;
if (commandArgs.IsCreateScoringModel)
{
modelAndFeatures = CreateScoringModel(commandArgs.ReintegratModelName,
commandArgs.IsDecoyModel, commandArgs.IsSecondBestModel);
if (modelAndFeatures == null)
return false;
}
else
{
PeakScoringModelSpec scoringModel;
if (!Settings.Default.PeakScoringModelList.TryGetValue(commandArgs.ReintegratModelName, out scoringModel))
{
_out.WriteLine(Resources.CommandLine_ReintegratePeaks_Error__Unknown_peak_scoring_model___0__);
return false;
}
modelAndFeatures = new ModelAndFeatures(scoringModel, null);
}
if (!Reintegrate(modelAndFeatures, commandArgs.IsAnnotateScoring, commandArgs.IsOverwritePeaks))
return false;
}
return true;
}
private bool SetFullScanSettings(CommandArgs commandArgs)
{
try
{
if (commandArgs.FullScanPrecursorRes.HasValue)
{
double res = commandArgs.FullScanPrecursorRes.Value;
double? resMz = commandArgs.FullScanPrecursorResMz;
if (!_doc.Settings.TransitionSettings.FullScan.IsHighResPrecursor)
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_precursor_resolution_to__0__, res);
else if (resMz.HasValue)
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_precursor_resolving_power_to__0__at__1__, res, resMz);
else
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_precursor_resolving_power_to__0__, res);
_doc = _doc.ChangeSettings(_doc.Settings.ChangeTransitionFullScan(f =>
f.ChangePrecursorResolution(f.PrecursorMassAnalyzer, res, resMz ?? f.PrecursorResMz)));
}
if (commandArgs.FullScanProductRes.HasValue)
{
double res = commandArgs.FullScanProductRes.Value;
double? resMz = commandArgs.FullScanProductResMz;
if (!_doc.Settings.TransitionSettings.FullScan.IsHighResProduct)
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_product_resolution_to__0__, res);
else if (resMz.HasValue)
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_product_resolving_power_to__0__at__1__, res, resMz);
else
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_product_resolving_power_to__0__, res);
_doc = _doc.ChangeSettings(_doc.Settings.ChangeTransitionFullScan(f =>
f.ChangeProductResolution(f.ProductMassAnalyzer, res, resMz ?? f.ProductResMz)));
}
if (commandArgs.FullScanRetentionTimeFilterLength.HasValue)
{
double rtLen = commandArgs.FullScanRetentionTimeFilterLength.Value;
if (_doc.Settings.TransitionSettings.FullScan.RetentionTimeFilterType == RetentionTimeFilterType.scheduling_windows)
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_extraction_to______0__minutes_from_predicted_value_, rtLen);
else if (_doc.Settings.TransitionSettings.FullScan.RetentionTimeFilterType == RetentionTimeFilterType.ms2_ids)
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Changing_full_scan_extraction_to______0__minutes_from_MS_MS_IDs_, rtLen);
_doc = _doc.ChangeSettings(_doc.Settings.ChangeTransitionFullScan(f =>
f.ChangeRetentionTimeFilter(f.RetentionTimeFilterType, rtLen)));
}
return true;
}
catch (Exception x)
{
_out.WriteLine(Resources.CommandLine_SetFullScanSettings_Error__Failed_attempting_to_change_the_transiton_full_scan_settings_);
_out.WriteLine(x.Message);
return false;
}
}
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 bool ImportSearch(CommandArgs commandArgs)
{
var doc = Document;
try
{
return ImportSearchInternal(commandArgs, ref doc);
}
finally
{
if (doc != null)
ImportPeptideSearch.ClosePeptideSearchLibraryStreams(doc);
}
}
private void ImportFoundResultsFiles(CommandArgs commandArgs, ImportPeptideSearch import)
{
foreach (var resultFile in import.GetFoundResultsFiles())
{
var filePath = new MsDataFilePath(resultFile.Path);
if (!_doc.Settings.HasResults || _doc.Settings.MeasuredResults.FindMatchingMSDataFile(filePath) == null)
{
if (!ImportResultsFile(filePath.ChangeParameters(_doc, commandArgs.LockMassParameters), resultFile.Name, null, null, null))
break; // Lots of work completed, still want to save
}
}
}
// This function needs so many variables, we might as well just pass the whole CommandArgs object
private void ExportInstrumentFile(ExportFileType type, CommandArgs args)
{
if (string.IsNullOrEmpty(args.ExportPath))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_);
return;
}
if (Equals(type, ExportFileType.Method))
{
if (string.IsNullOrEmpty(args.TemplateFile))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__A_template_file_is_required_to_export_a_method_);
return;
}
if (Equals(args.MethodInstrumentType, ExportInstrumentType.AGILENT6400)
? !Directory.Exists(args.TemplateFile)
: !File.Exists(args.TemplateFile))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__The_template_file__0__does_not_exist_, args.TemplateFile);
return;
}
if (Equals(args.MethodInstrumentType, ExportInstrumentType.AGILENT6400) &&
!AgilentMethodExporter.IsAgilentMethodPath(args.TemplateFile))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__The_folder__0__does_not_appear_to_contain_an_Agilent_QQQ_method_template___The_folder_is_expected_to_have_a__m_extension__and_contain_the_file_qqqacqmethod_xsd_, args.TemplateFile);
return;
}
}
if (!args.ExportStrategySet)
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Warning__No_export_strategy_specified__from__single____protein__or__buckets____Defaulting_to__single__);
args.ExportStrategy = ExportStrategy.Single;
}
if (args.AddEnergyRamp && !Equals(args.TransListInstrumentType, ExportInstrumentType.THERMO))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Warning__The_add_energy_ramp_parameter_is_only_applicable_for_Thermo_transition_lists__This_parameter_will_be_ignored_);
}
string instrument = Equals(type, ExportFileType.List)
? args.TransListInstrumentType
: args.MethodInstrumentType;
if (!CheckInstrument(instrument, _doc))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Warning__The_vendor__0__does_not_match_the_vendor_in_either_the_CE_or_DP_prediction_setting___Continuing_exporting_a_transition_list_anyway___, instrument);
}
int maxInstrumentTrans = _doc.Settings.TransitionSettings.Instrument.MaxTransitions ??
TransitionInstrument.MAX_TRANSITION_MAX;
if ((args.MaxTransitionsPerInjection < AbstractMassListExporter.MAX_TRANS_PER_INJ_MIN ||
args.MaxTransitionsPerInjection > maxInstrumentTrans) &&
(Equals(args.ExportStrategy, ExportStrategy.Buckets) ||
Equals(args.ExportStrategy, ExportStrategy.Protein)))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Warning__Max_transitions_per_injection_must_be_set_to_some_value_between__0__and__1__for_export_strategies__protein__and__buckets__and_for_scheduled_methods__You_specified__3___Defaulting_to__2__, AbstractMassListExporter.MAX_TRANS_PER_INJ_MIN, maxInstrumentTrans,AbstractMassListExporter.MAX_TRANS_PER_INJ_DEFAULT, args.MaxTransitionsPerInjection);
args.MaxTransitionsPerInjection = AbstractMassListExporter.MAX_TRANS_PER_INJ_DEFAULT;
}
/*
* Consider: for transition lists, AB Sciex and Agilent require the
* dwell time parameter, and Waters requires the run length parameter.
* These are guaranteed to be set and within-bounds at this point, but
* not necessarily by the user because there is a default.
*
* Should we warn the user that they didn't set these parameters?
* Should we warn the user if they set parameters that will not be used
* with the given instrument?
*
* This would require a pretty big matrix of conditionals, and there is
* documentation after all...
*/
if(Equals(type, ExportFileType.Method))
{
string extension = Path.GetExtension(args.TemplateFile);
if(!Equals(ExportInstrumentType.MethodExtension(args.MethodInstrumentType),extension))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__The_template_extension__0__does_not_match_the_expected_extension_for_the_instrument__1___No_method_will_be_exported_, extension,args.MethodInstrumentType);
return;
}
}
var prediction = _doc.Settings.TransitionSettings.Prediction;
double optimizeStepSize = 0;
int optimizeStepCount = 0;
if (Equals(args.ExportOptimizeType, ExportOptimize.CE))
{
var regression = prediction.CollisionEnergy;
optimizeStepSize = regression.StepSize;
optimizeStepCount = regression.StepCount;
}
else if (Equals(args.ExportOptimizeType, ExportOptimize.DP))
{
var regression = prediction.DeclusteringPotential;
optimizeStepSize = regression.StepSize;
optimizeStepCount = regression.StepCount;
}
//Now is a good time to make this conversion
_exportProperties = args.ExportCommandProperties;
_exportProperties.OptimizeStepSize = optimizeStepSize;
_exportProperties.OptimizeStepCount = optimizeStepCount;
_exportProperties.FullScans = _doc.Settings.TransitionSettings.FullScan.IsEnabledMsMs;
_exportProperties.Ms1Scan = _doc.Settings.TransitionSettings.FullScan.IsEnabledMs &&
_doc.Settings.TransitionSettings.FullScan.IsEnabledMsMs;
_exportProperties.InclusionList = _doc.Settings.TransitionSettings.FullScan.IsEnabledMs &&
!_doc.Settings.TransitionSettings.FullScan.IsEnabledMsMs;
_exportProperties.MsAnalyzer =
TransitionFullScan.MassAnalyzerToString(
_doc.Settings.TransitionSettings.FullScan.PrecursorMassAnalyzer);
_exportProperties.MsMsAnalyzer =
TransitionFullScan.MassAnalyzerToString(
_doc.Settings.TransitionSettings.FullScan.ProductMassAnalyzer);
_exportProperties.MsAnalyzer =
TransitionFullScan.MassAnalyzerToString(
_doc.Settings.TransitionSettings.FullScan.PrecursorMassAnalyzer);
_exportProperties.MsMsAnalyzer =
TransitionFullScan.MassAnalyzerToString(
_doc.Settings.TransitionSettings.FullScan.ProductMassAnalyzer);
if(!Equals(args.ExportMethodType, ExportMethodType.Standard))
{
if (Equals(args.ExportMethodType, ExportMethodType.Triggered))
{
bool canTrigger = true;
if (!ExportInstrumentType.CanTriggerInstrumentType(instrument))
{
canTrigger = false;
if (Equals(args.MethodInstrumentType, ExportInstrumentType.THERMO_TSQ))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__the__0__instrument_lacks_support_for_direct_method_export_for_triggered_acquisition_, instrument);
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_You_must_export_a__0__transition_list_and_manually_import_it_into_a_method_file_using_vendor_software_, ExportInstrumentType.THERMO);
}
else
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__the_instrument_type__0__does_not_support_triggered_acquisition_, instrument);
}
}
else if (!_doc.Settings.HasResults && !_doc.Settings.HasLibraries)
{
canTrigger = false;
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__triggered_acquistion_requires_a_spectral_library_or_imported_results_in_order_to_rank_transitions_);
}
else if (!ExportInstrumentType.CanTrigger(instrument, _doc, _exportProperties.SchedulingReplicateNum))
{
canTrigger = false;
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__The_current_document_contains_peptides_without_enough_information_to_rank_transitions_for_triggered_acquisition_);
}
if (!canTrigger)
{
_out.WriteLine(Equals(type, ExportFileType.List)
? Resources.CommandLine_ExportInstrumentFile_No_list_will_be_exported_
: Resources.CommandLine_ExportInstrumentFile_No_method_will_be_exported_);
return;
}
_exportProperties.PrimaryTransitionCount = args.PrimaryTransitionCount;
}
if (!ExportInstrumentType.CanSchedule(instrument, _doc))
{
var predictionPep = _doc.Settings.PeptideSettings.Prediction;
if (!ExportInstrumentType.CanScheduleInstrumentType(instrument, _doc))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__the_specified_instrument__0__is_not_compatible_with_scheduled_methods_,
instrument);
}
else if (predictionPep.RetentionTime == null)
{
if (predictionPep.UseMeasuredRTs)
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__to_export_a_scheduled_method__you_must_first_choose_a_retention_time_predictor_in_Peptide_Settings___Prediction__or_import_results_for_all_peptides_in_the_document_);
}
else
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__to_export_a_scheduled_method__you_must_first_choose_a_retention_time_predictor_in_Peptide_Settings___Prediction_);
}
}
else if (!predictionPep.RetentionTime.Calculator.IsUsable)
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__the_retention_time_prediction_calculator_is_unable_to_score___Check_the_calculator_settings_);
}
else if (!predictionPep.RetentionTime.IsUsable)
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__the_retention_time_predictor_is_unable_to_auto_calculate_a_regression___Check_to_make_sure_the_document_contains_times_for_all_of_the_required_standard_peptides_);
}
else
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__To_export_a_scheduled_method__you_must_first_import_results_for_all_peptides_in_the_document_);
}
_out.WriteLine(Equals(type, ExportFileType.List)
? Resources.CommandLine_ExportInstrumentFile_No_list_will_be_exported_
: Resources.CommandLine_ExportInstrumentFile_No_method_will_be_exported_);
return;
}
if (Equals(args.ExportSchedulingAlgorithm, ExportSchedulingAlgorithm.Average))
{
_exportProperties.SchedulingReplicateNum = null;
}
else
{
if(args.SchedulingReplicate.Equals("LAST")) // Not L10N
{
_exportProperties.SchedulingReplicateNum = _doc.Settings.MeasuredResults.Chromatograms.Count - 1;
}
else
{
//check whether the given replicate exists
if (!_doc.Settings.MeasuredResults.ContainsChromatogram(args.SchedulingReplicate))
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__the_specified_replicate__0__does_not_exist_in_the_document_,
args.SchedulingReplicate);
_out.WriteLine(Equals(type, ExportFileType.List)
? Resources.CommandLine_ExportInstrumentFile_No_list_will_be_exported_
: Resources.CommandLine_ExportInstrumentFile_No_method_will_be_exported_);
return;
}
_exportProperties.SchedulingReplicateNum =
_doc.Settings.MeasuredResults.Chromatograms.IndexOf(
rep => rep.Name.Equals(args.SchedulingReplicate));
}
}
}
try
{
_exportProperties.ExportFile(instrument, type, args.ExportPath, _doc, args.TemplateFile);
}
catch (IOException x)
{
_out.WriteLine(Resources.CommandLine_ExportInstrumentFile_Error__The_file__0__could_not_be_saved___Check_that_the_specified_file_directory_exists_and_is_writeable_, args.ExportPath);
_out.WriteLine(x.Message);
return;
}
_out.WriteLine(Equals(type, ExportFileType.List)
? Resources.CommandLine_ExportInstrumentFile_List__0__exported_successfully_
: Resources.CommandLine_ExportInstrumentFile_Method__0__exported_successfully_,
Path.GetFileName(args.ExportPath));
}
