public void TestCollectStatistics()
{
var testFilesDir = new TestFilesDir(TestContext, ZIP_FILE);
string docPath = testFilesDir.GetTestPath("BSA_Protea_label_free_20100323_meth3_multi.sky");
SrmDocument doc = ResultsUtil.DeserializeDocument(docPath);
var docContainer = new ResultsTestDocumentContainer(doc, docPath);
// Import the first RAW file (or mzML for international)
string rawPath = testFilesDir.GetTestPath("ah_20101011y_BSA_MS-MS_only_5-2" +
ExtensionTestContext.ExtThermoRaw);
var measuredResults = new MeasuredResults(new[] { new ChromatogramSet("Single", new[] { MsDataFileUri.Parse(rawPath) }) });
SrmDocument docResults = docContainer.ChangeMeasuredResults(measuredResults, 3, 3, 21);
ChromCacheMinimizer chromCacheMinimizer =
docResults.Settings.MeasuredResults.GetChromCacheMinimizer(docResults);
ChromCacheMinimizer.Settings settings =
new ChromCacheMinimizer.Settings().SetDiscardUnmatchedChromatograms(true);
ChromCacheMinimizer.MinStatistics minStatistics = null;
chromCacheMinimizer.Minimize(settings, s => minStatistics = s, null);
Assert.AreEqual(100, minStatistics.PercentComplete);
Assert.AreEqual(1.0, minStatistics.MinimizedRatio);
var docMissingFirstPeptide =
(SrmDocument)
docResults.ReplaceChild(
docResults.PeptideGroups.First().RemoveChild(docResults.PeptideGroups.First().Children[0]));
var docWithOnlyFirstPeptide =
(SrmDocument)
docResults.ReplaceChild(
docResults.PeptideGroups.First().ChangeChildren(new[] { docResults.PeptideGroups.First().Children[0] }));
ChromCacheMinimizer.MinStatistics statsMissingFirstProtein = null;
ChromCacheMinimizer.MinStatistics statsWithOnlyFirstProtein = null;
settings = settings.SetDiscardUnmatchedChromatograms(true);
ChromCacheMinimizer minimizerMissingFirstProtein =
docMissingFirstPeptide.Settings.MeasuredResults.GetChromCacheMinimizer(docMissingFirstPeptide);
ChromCacheMinimizer minimizerWithOnlyFirstProtein =
docWithOnlyFirstPeptide.Settings.MeasuredResults.GetChromCacheMinimizer(docWithOnlyFirstPeptide);
minimizerMissingFirstProtein.Minimize(settings, s => statsMissingFirstProtein = s, null);
minimizerWithOnlyFirstProtein.Minimize(settings, s => statsWithOnlyFirstProtein = s, null);
Assert.AreEqual(100, statsMissingFirstProtein.PercentComplete);
Assert.AreEqual(100, statsWithOnlyFirstProtein.PercentComplete);
Assert.AreEqual(1.0, statsMissingFirstProtein.MinimizedRatio + statsWithOnlyFirstProtein.MinimizedRatio,
.00001);
settings = settings.SetDiscardUnmatchedChromatograms(false);
ChromCacheMinimizer.MinStatistics statsMissingFirstProteinKeepAll = null;
ChromCacheMinimizer.MinStatistics statsWithOnlyFirstProteinKeepAll = null;
minimizerMissingFirstProtein.Minimize(settings, s => statsMissingFirstProteinKeepAll = s, null);
minimizerWithOnlyFirstProtein.Minimize(settings, s => statsWithOnlyFirstProteinKeepAll = s, null);
Assert.AreEqual(100, statsMissingFirstProteinKeepAll.PercentComplete);
Assert.AreEqual(1.0, statsMissingFirstProteinKeepAll.MinimizedRatio);
Assert.AreEqual(100, statsWithOnlyFirstProteinKeepAll.PercentComplete);
Assert.AreEqual(1.0, statsWithOnlyFirstProteinKeepAll.MinimizedRatio);
docContainer.Release();
}
public void NeutralLossListTest()
{
TestSmallMolecules = false; // No concept of neutral loss for small molecules
var phosphoLossMod = new StaticMod("Phospho Loss", "S, T, Y", null, false, "HPO3",
LabelAtoms.None, RelativeRT.Matching, null, null, new[] { new FragmentLoss("H3PO4"), });
SrmDocument document = new SrmDocument(SrmSettingsList.GetDefault().ChangePeptideModifications(mods =>
mods.ChangeStaticModifications(new List <StaticMod>(mods.StaticModifications)
{
phosphoLossMod
})));
IdentityPath path = IdentityPath.ROOT;
SrmDocument docFasta = document.ImportFasta(new StringReader(TEXT_FASTA_YEAST_7), false, path, out path);
Assert.AreEqual(0, GetLossCount(docFasta, 1));
// Insert losses into the first transition group
var pathPeptide = docFasta.GetPathTo((int)SrmDocument.Level.Molecules, 0);
var nodePep = (PeptideDocNode)docFasta.FindNode(pathPeptide);
var nodeGroup = (TransitionGroupDocNode)nodePep.Children[0];
var listChildren = new List <DocNode>(nodeGroup.Children);
foreach (var nodeTran in nodeGroup.GetTransitions(docFasta.Settings,
nodePep.ExplicitMods, nodeGroup.PrecursorMz, null, null, null, false))
{
if (!nodeTran.HasLoss)
{
continue;
}
var tran = nodeTran.Transition;
int matchIndex = listChildren.IndexOf(node =>
Equals(tran, ((TransitionDocNode)node).Transition));
if (matchIndex == -1)
{
continue;
}
while (matchIndex < listChildren.Count &&
Equals(tran, ((TransitionDocNode)listChildren[matchIndex]).Transition))
{
matchIndex++;
}
listChildren.Insert(matchIndex, nodeTran);
}
var docLosses = (SrmDocument)docFasta.ReplaceChild(pathPeptide,
nodeGroup.ChangeChildren(listChildren));
int lossCount = GetLossCount(docLosses, 1);
Assert.IsTrue(lossCount > 0);
var docRoundTripped = AssertEx.RoundTripTransitionList(new ThermoMassListExporter(docLosses));
Assert.AreEqual(lossCount, GetLossCount(docRoundTripped, 1));
docRoundTripped = AssertEx.RoundTripTransitionList(new AgilentMassListExporter(docLosses));
Assert.AreEqual(lossCount, GetLossCount(docRoundTripped, 1));
}
public SrmDocument SetDocNodeAnnotations(SrmDocument document, NodeRef nodeRef, Annotations annotations)
{
var identityPath = ToIdentityPath(nodeRef);
var docNode = document.FindNode(identityPath);
docNode = docNode.ChangeAnnotations(annotations);
document = (SrmDocument)document.ReplaceChild(identityPath.Parent, docNode);
return(document);
}
public SrmDocument SetResultAnnotations(SrmDocument document, ResultRef resultRef, Annotations annotations)
{
var measuredResults = document.MeasuredResults;
if (measuredResults == null)
{
throw ElementNotFoundException(resultRef);
}
var nodeRef = (NodeRef)resultRef.Parent;
var identityPath = ToIdentityPath(nodeRef);
var docNode = document.FindNode(identityPath);
for (int replicateIndex = 0; replicateIndex < measuredResults.Chromatograms.Count; replicateIndex++)
{
var chromSet = measuredResults.Chromatograms[replicateIndex];
if (resultRef.Matches(chromSet))
{
var transitionGroup = docNode as TransitionGroupDocNode;
if (transitionGroup != null)
{
var results = transitionGroup.Results.ToArray();
results[replicateIndex] = SetChromInfoAnnotations(chromSet, (PrecursorResultRef)resultRef,
results[replicateIndex], annotations);
docNode = ((TransitionGroupDocNode)docNode).ChangeResults(
new Results <TransitionGroupChromInfo>(results));
}
else
{
var transition = docNode as TransitionDocNode;
if (transition != null)
{
var results = transition.Results.ToArray();
results[replicateIndex] = SetChromInfoAnnotations(chromSet, (TransitionResultRef)resultRef,
results[replicateIndex], annotations);
docNode = ((TransitionDocNode)docNode).ChangeResults(
new Results <TransitionChromInfo>(results));
}
else
{
throw AnnotationsNotSupported(resultRef);
}
}
return((SrmDocument)document.ReplaceChild(identityPath.Parent, docNode));
}
}
throw ElementNotFoundException(resultRef);
}
private SrmDocument RenameProtein(SrmDocument doc, RenameProteinsDlg dlg)
{
foreach (var name in dlg.DictNameToName.Keys)
{
PeptideGroupDocNode node = Document.MoleculeGroups.FirstOrDefault(peptideGroup => Equals(name, peptideGroup.Name));
if (node != null)
{
var renameProtein = new RenameProteinsDlg.RenameProteins {
CurrentName = name, NewName = dlg.DictNameToName[name]
};
if (renameProtein.CurrentName != renameProtein.NewName)
{
doc = (SrmDocument)doc.ReplaceChild(node.ChangeName(renameProtein.NewName));
}
}
}
return(doc);
}
private SrmDocument SetExcludeStandard(SrmDocument document, IdentityPath peptideIdPath, int resultsIndex, bool exclude)
{
if (!document.Settings.HasResults)
{
return document;
}
var peptideDocNode = (PeptideDocNode) document.FindNode(peptideIdPath);
if (peptideDocNode == null)
{
return document;
}
if (resultsIndex < 0 || resultsIndex >= document.Settings.MeasuredResults.Chromatograms.Count)
{
return document;
}
bool wasExcluded = peptideDocNode.IsExcludeFromCalibration(resultsIndex);
return (SrmDocument) document.ReplaceChild(peptideIdPath.Parent,
peptideDocNode.ChangeExcludeFromCalibration(resultsIndex, !wasExcluded));
}
/// <summary>
/// Removes peaks and annotations that were in the document but not in the file, so that all peptide results that were not explicitly imported as part of this file are now blank
/// </summary>
/// <param name="docNew">SrmDocument for which missing peaks should be removed</param>
/// <param name="trackAdjustedResults">List of peaks that were in the imported file</param>
/// <param name="changePeaks">If true, remove both peaks and annotations. If false, only remove annotations</param>
/// <returns></returns>
private SrmDocument RemoveMissing(SrmDocument docNew, ICollection <ResultsKey> trackAdjustedResults, bool changePeaks)
{
var measuredResults = docNew.Settings.MeasuredResults;
var chromatogramSets = measuredResults.Chromatograms;
for (int i = 0; i < chromatogramSets.Count; ++i)
{
var set = chromatogramSets[i];
var nameSet = set.Name;
for (int k = 0; k < docNew.MoleculeCount; ++k)
{
IdentityPath pepPath = docNew.GetPathTo((int)SrmDocument.Level.Molecules, k);
var pepNode = (PeptideDocNode)Document.FindNode(pepPath);
if (pepNode.IsDecoy)
{
continue;
}
if (pepNode.GlobalStandardType != null)
{
continue;
}
foreach (var groupNode in pepNode.TransitionGroups)
{
var groupPath = new IdentityPath(pepPath, groupNode.Id);
var chromInfos = groupNode.Results[i];
if (chromInfos.IsEmpty)
{
continue;
}
foreach (var groupChromInfo in chromInfos)
{
if (groupChromInfo == null)
{
continue;
}
var key = new ResultsKey(groupChromInfo.FileId.GlobalIndex, groupNode.Id);
if (!trackAdjustedResults.Contains(key))
{
CountMissing++;
var fileId = groupChromInfo.FileId;
var fileInfo = set.GetFileInfo(fileId);
var filePath = fileInfo.FilePath;
// Remove annotations for defs that were imported into the document and were on this peptide prior to import
var newAnnotationValues = groupChromInfo.Annotations.ListAnnotations().ToList();
newAnnotationValues = newAnnotationValues.Where(a => !AnnotationsAdded.Contains(a.Key)).ToList();
var newAnnotations = new Annotations(groupChromInfo.Annotations.Note, newAnnotationValues, groupChromInfo.Annotations.ColorIndex);
var newGroupNode = groupNode.ChangePrecursorAnnotations(fileId, newAnnotations);
if (!ReferenceEquals(groupNode, newGroupNode))
{
docNew = (SrmDocument)docNew.ReplaceChild(groupPath.Parent, newGroupNode);
}
// Adjust peaks to null if they weren't in the file
if (changePeaks)
{
docNew = docNew.ChangePeak(groupPath, nameSet, filePath,
null, null, null, UserSet.IMPORTED, null, false);
}
}
}
}
}
}
return(docNew);
}
/// <summary>
/// Removes peaks and annotations that were in the document but not in the file, so that all peptide results that were not explicitly imported as part of this file are now blank
/// </summary>
/// <param name="docNew">SrmDocument for which missing peaks should be removed</param>
/// <param name="trackAdjustedResults">List of peaks that were in the imported file</param>
/// <param name="changePeaks">If true, remove both peaks and annotations. If false, only remove annotations</param>
/// <returns></returns>
private SrmDocument RemoveMissing(SrmDocument docNew, ICollection<ResultsKey> trackAdjustedResults, bool changePeaks)
{
var measuredResults = docNew.Settings.MeasuredResults;
var chromatogramSets = measuredResults.Chromatograms;
for (int i = 0; i < chromatogramSets.Count; ++i)
{
var set = chromatogramSets[i];
var nameSet = set.Name;
for (int k = 0; k < docNew.MoleculeCount; ++k)
{
IdentityPath pepPath = docNew.GetPathTo((int)SrmDocument.Level.Molecules, k);
var pepNode = (PeptideDocNode)Document.FindNode(pepPath);
if (pepNode.IsDecoy)
continue;
if (pepNode.GlobalStandardType != null)
continue;
foreach (var groupNode in pepNode.TransitionGroups)
{
var groupPath = new IdentityPath(pepPath, groupNode.Id);
var chromInfos = groupNode.Results[i];
if (chromInfos == null)
continue;
foreach (var groupChromInfo in chromInfos)
{
if (groupChromInfo == null)
continue;
var key = new ResultsKey(groupChromInfo.FileId.GlobalIndex, groupNode.Id);
if (!trackAdjustedResults.Contains(key))
{
CountMissing++;
var fileId = groupChromInfo.FileId;
var fileInfo = set.GetFileInfo(fileId);
var filePath = fileInfo.FilePath;
// Remove annotations for defs that were imported into the document and were on this peptide prior to import
var newAnnotationValues = groupChromInfo.Annotations.ListAnnotations().ToList();
newAnnotationValues = newAnnotationValues.Where(a => !AnnotationsAdded.Contains(a.Key)).ToList();
var newAnnotations = new Annotations(groupChromInfo.Annotations.Note, newAnnotationValues, groupChromInfo.Annotations.ColorIndex);
var newGroupNode = groupNode.ChangePrecursorAnnotations(fileId, newAnnotations);
if (!ReferenceEquals(groupNode, newGroupNode))
docNew = (SrmDocument) docNew.ReplaceChild(groupPath.Parent, newGroupNode);
// Adjust peaks to null if they weren't in the file
if (changePeaks)
{
docNew = docNew.ChangePeak(groupPath, nameSet, filePath,
null, null, null, UserSet.IMPORTED, null, false);
}
}
}
}
}
}
return docNew;
}
private SrmDocument AddPeptides(SrmDocument document, bool validating, ref IdentityPath selectedPath)
{
if (tabControl1.SelectedTab != tabPagePeptideList)
return document;
var matcher = new ModificationMatcher();
var listPeptideSequences = ListPeptideSequences();
if (listPeptideSequences == null)
return null;
try
{
matcher.CreateMatches(document.Settings, listPeptideSequences, Settings.Default.StaticModList,
Settings.Default.HeavyModList);
}
catch (FormatException e)
{
MessageDlg.ShowException(this, e);
ShowPeptideError(new PasteError
{
Column = colPeptideSequence.Index,
Message = Resources.PasteDlg_AddPeptides_Unable_to_interpret_peptide_modifications
});
return null;
}
var strNameMatches = matcher.FoundMatches;
if (!validating && !string.IsNullOrEmpty(strNameMatches))
{
string message = TextUtil.LineSeparate(Resources.PasteDlg_AddPeptides_Would_you_like_to_use_the_Unimod_definitions_for_the_following_modifications,
string.Empty, strNameMatches);
if (MultiButtonMsgDlg.Show(this, message, Resources.PasteDlg_AddPeptides_OK) == DialogResult.Cancel)
return null;
}
var backgroundProteome = GetBackgroundProteome(document);
// Insert last to first so that proteins get inserted on top of each other
// in the order they are added. Peptide insertion into peptide lists needs
// to be carefully tracked to insert them in the order they are listed in
// the grid.
int lastGroupGlobalIndex = 0, lastPeptideIndex = -1;
for (int i = gridViewPeptides.Rows.Count - 1; i >= 0; i--)
{
PeptideGroupDocNode peptideGroupDocNode;
var row = gridViewPeptides.Rows[i];
var pepModSequence = Convert.ToString(row.Cells[colPeptideSequence.Index].Value);
pepModSequence = FastaSequence.NormalizeNTerminalMod(pepModSequence);
var proteinName = Convert.ToString(row.Cells[colPeptideProtein.Index].Value);
if (string.IsNullOrEmpty(pepModSequence) && string.IsNullOrEmpty(proteinName))
continue;
if (string.IsNullOrEmpty(proteinName))
{
peptideGroupDocNode = GetSelectedPeptideGroupDocNode(document, selectedPath);
if (!IsPeptideListDocNode(peptideGroupDocNode))
{
peptideGroupDocNode = null;
}
}
else
{
peptideGroupDocNode = FindPeptideGroupDocNode(document, proteinName);
}
if (peptideGroupDocNode == null)
{
if (string.IsNullOrEmpty(proteinName))
{
peptideGroupDocNode = new PeptideGroupDocNode(new PeptideGroup(),
document.GetPeptideGroupId(true), null,
new PeptideDocNode[0]);
}
else
{
ProteinMetadata metadata = null;
PeptideGroup peptideGroup = backgroundProteome.IsNone ? new PeptideGroup()
: (backgroundProteome.GetFastaSequence(proteinName, out metadata) ??
new PeptideGroup());
if (metadata != null)
peptideGroupDocNode = new PeptideGroupDocNode(peptideGroup, metadata, new PeptideDocNode[0]);
else
peptideGroupDocNode = new PeptideGroupDocNode(peptideGroup, proteinName,
peptideGroup.Description, new PeptideDocNode[0]);
}
// Add to the end, if no insert node
var to = selectedPath;
if (to == null || to.Depth < (int)SrmDocument.Level.MoleculeGroups)
document = (SrmDocument)document.Add(peptideGroupDocNode);
else
{
Identity toId = selectedPath.GetIdentity((int) SrmDocument.Level.MoleculeGroups);
document = (SrmDocument) document.Insert(toId, peptideGroupDocNode);
}
selectedPath = new IdentityPath(peptideGroupDocNode.Id);
}
var peptides = new List<PeptideDocNode>();
foreach (PeptideDocNode peptideDocNode in peptideGroupDocNode.Children)
{
peptides.Add(peptideDocNode);
}
var fastaSequence = peptideGroupDocNode.PeptideGroup as FastaSequence;
PeptideDocNode nodePepNew;
if (fastaSequence != null)
{
// Attempt to create node for error checking.
nodePepNew = fastaSequence.CreateFullPeptideDocNode(document.Settings,
FastaSequence.StripModifications(pepModSequence));
if (nodePepNew == null)
{
ShowPeptideError(new PasteError
{
Column = colPeptideSequence.Index,
Line = i,
Message = Resources.PasteDlg_AddPeptides_This_peptide_sequence_was_not_found_in_the_protein_sequence
});
return null;
}
}
// Create node using ModificationMatcher.
nodePepNew = matcher.GetModifiedNode(pepModSequence, fastaSequence).ChangeSettings(document.Settings,
SrmSettingsDiff.ALL);
// Avoid adding an existing peptide a second time.
if (!peptides.Contains(nodePep => Equals(nodePep.Key, nodePepNew.Key)))
{
if (nodePepNew.Peptide.FastaSequence != null)
{
peptides.Add(nodePepNew);
peptides.Sort(FastaSequence.ComparePeptides);
}
else
{
int groupGlobalIndex = peptideGroupDocNode.PeptideGroup.GlobalIndex;
if (groupGlobalIndex == lastGroupGlobalIndex && lastPeptideIndex != -1)
{
peptides.Insert(lastPeptideIndex, nodePepNew);
}
else
{
lastPeptideIndex = peptides.Count;
peptides.Add(nodePepNew);
}
lastGroupGlobalIndex = groupGlobalIndex;
}
var newPeptideGroupDocNode = new PeptideGroupDocNode(peptideGroupDocNode.PeptideGroup, peptideGroupDocNode.Annotations, peptideGroupDocNode.Name, peptideGroupDocNode.Description, peptides.ToArray(), false);
document = (SrmDocument)document.ReplaceChild(newPeptideGroupDocNode);
}
}
if (!validating && listPeptideSequences.Count > 0)
{
var pepModsNew = matcher.GetDocModifications(document);
document = document.ChangeSettings(document.Settings.ChangePeptideModifications(mods => pepModsNew));
document.Settings.UpdateDefaultModifications(false);
}
return document;
}
private SrmDocument AddTransitionList(SrmDocument document, ref IdentityPath selectedPath)
{
if (tabControl1.SelectedTab != tabPageTransitionList)
return document;
if (IsMolecule)
{
// Save the current column order to settings
var active = new List<string>();
for (int order = 0; order < gridViewTransitionList.Columns.Count; order++)
{
for (int gridcol = 0; gridcol < gridViewTransitionList.Columns.Count; gridcol++)
{
var dataGridViewColumn = gridViewTransitionList.Columns[gridcol];
if (dataGridViewColumn.DisplayIndex == order)
{
if (dataGridViewColumn.Visible)
active.Add(dataGridViewColumn.Name);
break;
}
}
}
Settings.Default.CustomMoleculeTransitionInsertColumnsList = active;
// We will accept a completely empty product list as meaning
// "these are all precursor transitions"
var requireProductInfo = false;
for (var i = 0; i < gridViewTransitionList.RowCount - 1; i++)
{
var row = gridViewTransitionList.Rows[i];
var productMz = row.Cells[INDEX_PRODUCT_MZ].Value;
var productFormula = row.Cells[INDEX_PRODUCT_FORMULA].Value;
var productCharge = row.Cells[INDEX_PRODUCT_CHARGE].Value;
if ((productMz != null && productMz.ToString().Length > 0) ||
(productFormula != null && productFormula.ToString().Length > 0) ||
(productCharge != null && productCharge.ToString().Length > 0))
{
requireProductInfo = true; // Product list is not completely empty
break;
}
}
// For each row in the grid, add to or begin MoleculeGroup|Molecule|TransitionList tree
for(int i = 0; i < gridViewTransitionList.RowCount - 1; i ++)
{
DataGridViewRow row = gridViewTransitionList.Rows[i];
var precursor = ReadPrecursorOrProductColumns(document, row, true); // Get molecule values
if (precursor == null)
return null;
if (requireProductInfo && ReadPrecursorOrProductColumns(document, row, false) == null)
{
return null;
}
var charge = precursor.Charge;
var precursorMonoMz = BioMassCalc.CalculateIonMz(precursor.MonoMass, charge);
var precursorAverageMz = BioMassCalc.CalculateIonMz(precursor.AverageMass, charge);
// Preexisting molecule group?
bool pepGroupFound = false;
foreach (var pepGroup in document.MoleculeGroups)
{
var pathPepGroup = new IdentityPath(pepGroup.Id);
if (Equals(pepGroup.Name, Convert.ToString(row.Cells[INDEX_MOLECULE_GROUP].Value)))
{
// Found a molecule group with the same name - can we find an existing transition group to which we can add a transition?
pepGroupFound = true;
bool pepFound = false;
foreach (var pep in pepGroup.SmallMolecules)
{
var pepPath = new IdentityPath(pathPepGroup, pep.Id);
var ionMonoMz = BioMassCalc.CalculateIonMz(pep.CustomIon.MonoisotopicMass, charge);
var ionAverageMz = BioMassCalc.CalculateIonMz(pep.CustomIon.AverageMass, charge);
// Match existing molecule if same name (if any) and same formula (if any) and similar m/z at the precursor charge
// (we don't just check mass since we don't have a tolerance value for that)
// Or same name If any) and identical formula when stripped of labels
// Or same name, no formula, and different isotope labels
if (Equals(pep.CustomIon.Name, precursor.Name) &&
((Equals(pep.CustomIon.Formula, precursor.Formula) &&
Math.Abs(ionMonoMz - precursorMonoMz) <= document.Settings.TransitionSettings.Instrument.MzMatchTolerance &&
Math.Abs(ionAverageMz - precursorAverageMz) <= document.Settings.TransitionSettings.Instrument.MzMatchTolerance) ||
(!Equals(pep.CustomIon.Formula, precursor.Formula) &&
Equals(pep.CustomIon.UnlabeledFormula, BioMassCalc.MONOISOTOPIC.StripLabelsFromFormula(precursor.Formula))) ||
(string.IsNullOrEmpty(pep.CustomIon.Formula) && string.IsNullOrEmpty(precursor.Formula) &&
!pep.TransitionGroups.Any(t => Equals(t.TransitionGroup.LabelType, precursor.IsotopeLabelType??IsotopeLabelType.light))) ))
{
pepFound = true;
bool tranGroupFound = false;
foreach (var tranGroup in pep.TransitionGroups)
{
var pathGroup = new IdentityPath(pepPath, tranGroup.Id);
if (Math.Abs(tranGroup.PrecursorMz - precursor.Mz) <= document.Settings.TransitionSettings.Instrument.MzMatchTolerance)
{
tranGroupFound = true;
var tranFound = false;
try
{
var tranNode = GetMoleculeTransition(document, row, pep.Peptide, tranGroup.TransitionGroup, requireProductInfo);
if (tranNode == null)
return null;
foreach (var tran in tranGroup.Transitions)
{
if (Equals(tranNode.Transition.CustomIon,tran.Transition.CustomIon))
{
tranFound = true;
break;
}
}
if (!tranFound)
{
document = (SrmDocument) document.Add(pathGroup, tranNode);
}
}
catch (InvalidDataException e)
{
// Some error we didn't catch in the basic checks
ShowTransitionError(new PasteError
{
Column = 0,
Line = row.Index,
Message = e.Message
});
return null;
}
break;
}
}
if (!tranGroupFound)
{
var node = GetMoleculeTransitionGroup(document, row, pep.Peptide, requireProductInfo);
if (node == null)
return null;
document =
(SrmDocument)
document.Add(pepPath, node);
}
break;
}
}
if (!pepFound)
{
var node = GetMoleculePeptide(document, row, pepGroup.PeptideGroup, requireProductInfo);
if (node == null)
return null;
document =
(SrmDocument)
document.Add(pathPepGroup,node);
}
break;
}
}
if (!pepGroupFound)
{
var node = GetMoleculePeptideGroup(document, row, requireProductInfo);
if (node == null)
return null;
IdentityPath first;
IdentityPath next;
document =
document.AddPeptideGroups(new[] {node}, false,null
, out first,out next);
}
}
}
else
{
var backgroundProteome = GetBackgroundProteome(document);
var sbTransitionList = new StringBuilder();
var dictNameSeq = new Dictionary<string, FastaSequence>();
// Add all existing FASTA sequences in the document to the name to seq dictionary
// Including named peptide lists would cause the import code to give matching names
// in this list new names (e.g. with 1, 2, 3 appended). In this code, the names
// are intended to be merged.
foreach (var nodePepGroup in document.Children.Cast<PeptideGroupDocNode>().Where(n => !n.IsPeptideList))
{
if (!dictNameSeq.ContainsKey(nodePepGroup.Name))
dictNameSeq.Add(nodePepGroup.Name, (FastaSequence) nodePepGroup.PeptideGroup);
}
// Check for simple errors and build strings for import
for (int i = 0; i < gridViewTransitionList.Rows.Count; i++)
{
var row = gridViewTransitionList.Rows[i];
var peptideSequence = Convert.ToString(row.Cells[colTransitionPeptide.Index].Value);
var proteinName = Convert.ToString(row.Cells[colTransitionProteinName.Index].Value);
var precursorMzText = Convert.ToString(row.Cells[colTransitionPrecursorMz.Index].Value);
var productMzText = Convert.ToString(row.Cells[colTransitionProductMz.Index].Value);
if (string.IsNullOrEmpty(peptideSequence) && string.IsNullOrEmpty(proteinName))
{
continue;
}
if (string.IsNullOrEmpty(peptideSequence))
{
ShowTransitionError(new PasteError
{
Column = colTransitionPeptide.Index,
Line = i,
Message = Resources.PasteDlg_ListPeptideSequences_The_peptide_sequence_cannot_be_blank
});
return null;
}
if (!FastaSequence.IsExSequence(peptideSequence))
{
ShowTransitionError(new PasteError
{
Column = colTransitionPeptide.Index,
Line = i,
Message = Resources.PasteDlg_ListPeptideSequences_This_peptide_sequence_contains_invalid_characters
});
return null;
}
double mz;
if (!double.TryParse(precursorMzText, out mz))
{
ShowTransitionError(new PasteError
{
Column = colTransitionPrecursorMz.Index,
Line = i,
Message = Resources.PasteDlg_AddTransitionList_The_precursor_m_z_must_be_a_number_
});
return null;
}
if (!double.TryParse(productMzText, out mz))
{
ShowTransitionError(new PasteError
{
Column = colTransitionProductMz.Index,
Line = i,
Message = Resources.PasteDlg_AddTransitionList_The_product_m_z_must_be_a_number_
});
return null;
}
const char sep = TRANSITION_LIST_SEPARATOR;
// Add columns in order specified by TRANSITION_LIST_COL_INDICES
sbTransitionList
.Append(proteinName).Append(sep)
.Append(peptideSequence).Append(sep)
.Append(precursorMzText).Append(sep)
.Append(productMzText).AppendLine();
// Build FASTA sequence text in cases where it is known
if (!dictNameSeq.ContainsKey(proteinName))
{
var fastaSeq = backgroundProteome.GetFastaSequence(proteinName);
if (fastaSeq != null)
dictNameSeq.Add(proteinName, fastaSeq);
}
}
if (sbTransitionList.Length == 0)
return document;
// Do the actual import into PeptideGroupDocNodes
IEnumerable<PeptideGroupDocNode> peptideGroupDocNodes;
try
{
List<TransitionImportErrorInfo> errorList;
List<MeasuredRetentionTime> irtPeptides;
List<SpectrumMzInfo> librarySpectra;
var inputs = new MassListInputs(sbTransitionList.ToString(), LocalizationHelper.CurrentCulture, TRANSITION_LIST_SEPARATOR);
var importer = new MassListImporter(document, inputs);
// TODO: support long-wait broker
peptideGroupDocNodes = importer.Import(null,
TRANSITION_LIST_COL_INDICES,
dictNameSeq,
out irtPeptides,
out librarySpectra,
out errorList);
if (errorList.Any())
{
var firstError = errorList[0];
if (firstError.Row.HasValue)
{
throw new LineColNumberedIoException(firstError.ErrorMessage, firstError.Row.Value, firstError.Column ?? -1);
}
else
{
throw new InvalidDataException(firstError.ErrorMessage);
}
}
}
catch (LineColNumberedIoException x)
{
var columns = new[]
{
colTransitionProteinName,
colPeptideSequence,
colTransitionPrecursorMz,
colTransitionProductMz
};
ShowTransitionError(new PasteError
{
Column = x.ColumnIndex >= 0 ? columns[x.ColumnIndex].Index : 0,
Line = (int) x.LineNumber - 1,
Message = x.PlainMessage
});
return null;
}
catch (InvalidDataException x)
{
ShowTransitionError(new PasteError
{
Message = x.Message
});
return null;
}
// Insert the resulting nodes into the document tree, merging when possible
bool after = false;
foreach (var nodePepGroup in peptideGroupDocNodes)
{
PeptideGroupDocNode nodePepGroupExist = FindPeptideGroupDocNode(document, nodePepGroup);
if (nodePepGroupExist != null)
{
var nodePepGroupNew = nodePepGroupExist.Merge(nodePepGroup);
if (!ReferenceEquals(nodePepGroupExist, nodePepGroupNew))
document = (SrmDocument) document.ReplaceChild(nodePepGroupNew);
}
else
{
// Add to the end, if no insert node
var to = selectedPath;
if (to == null || to.Depth < (int) SrmDocument.Level.MoleculeGroups)
document = (SrmDocument) document.Add(nodePepGroup);
else
{
Identity toId = selectedPath.GetIdentity((int) SrmDocument.Level.MoleculeGroups);
document = (SrmDocument) document.Insert(toId, nodePepGroup, after);
}
selectedPath = new IdentityPath(nodePepGroup.Id);
// All future insertions should be after, to avoid reversing the list
after = true;
}
}
}
return document;
}
public SrmDocument ConvertToExplicitRetentionTimes(SrmDocument document, double timeOffset, double winOffset)
{
for (bool changing = true; changing;)
{
changing = false;
foreach (var peptideGroupDocNode in document.MoleculeGroups)
{
var pepGroupPath = new IdentityPath(IdentityPath.ROOT, peptideGroupDocNode.Id);
foreach (var nodePep in peptideGroupDocNode.Molecules)
{
var pepPath = new IdentityPath(pepGroupPath, nodePep.Id);
var rt = nodePep.AverageMeasuredRetentionTime;
if (rt.HasValue)
{
double? rtWin = document.Settings.PeptideSettings.Prediction.MeasuredRTWindow;
var explicitRetentionTimeInfo = new ExplicitRetentionTimeInfo(rt.Value+timeOffset, rtWin+winOffset);
if (!explicitRetentionTimeInfo.Equals(nodePep.ExplicitRetentionTime))
{
document = (SrmDocument)document.ReplaceChild(pepPath.Parent, nodePep.ChangeExplicitRetentionTime(explicitRetentionTimeInfo));
changing = true;
break;
}
}
}
if (changing)
break;
}
}
return document;
}
private static SrmDocument AddPeptidesToLibraryGroup(SrmDocument document,
ICollection <PeptideMatch> listMatches,
ILongWaitBroker broker,
IdentityPath toPath,
out IdentityPath selectedPath)
{
// Get starting progress values
int startPercent = (broker != null ? broker.ProgressValue : 0);
int processedPercent = 0;
int processedCount = 0;
int totalMatches = listMatches.Count;
var listPeptides = new List <PeptideDocNode>();
var hasSmallMolecules = false;
foreach (var match in listMatches)
{
// Show progress, if in a long wait
if (broker != null)
{
if (broker.IsCanceled)
{
selectedPath = null;
return(document);
}
processedCount++;
int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
if (processedPercent != processPercentNow)
{
processedPercent = processPercentNow;
broker.ProgressValue = startPercent + processedPercent;
}
}
listPeptides.Add(match.NodePep.ChangeSettings(document.Settings, SrmSettingsDiff.ALL));
hasSmallMolecules |= !match.NodePep.IsProteomic;
}
bool hasVariable =
listPeptides.Contains(nodePep => nodePep.HasExplicitMods && nodePep.ExplicitMods.IsVariableStaticMods);
// Use existing group by this name, if present.
var nodeName = hasSmallMolecules
? Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Molecules
: Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Peptides;
var nodePepGroupNew = FindPeptideGroupDocNode(document, nodeName);
if (nodePepGroupNew != null)
{
var newChildren = nodePepGroupNew.Children.ToList();
newChildren.AddRange(listPeptides.ConvertAll(nodePep => (DocNode)nodePep));
selectedPath = (listPeptides.Count == 1 ? new IdentityPath(nodePepGroupNew.Id, listPeptides[0].Id) : toPath);
nodePepGroupNew = (PeptideGroupDocNode)nodePepGroupNew.ChangeChildren(newChildren);
if (hasVariable)
{
nodePepGroupNew = (PeptideGroupDocNode)nodePepGroupNew.ChangeAutoManageChildren(false);
}
return((SrmDocument)document.ReplaceChild(nodePepGroupNew));
}
else
{
nodePepGroupNew = new PeptideGroupDocNode(new PeptideGroup(),
nodeName,
string.Empty, listPeptides.ToArray());
if (hasVariable)
{
nodePepGroupNew = (PeptideGroupDocNode)nodePepGroupNew.ChangeAutoManageChildren(false);
}
IdentityPath nextAdd;
document = document.AddPeptideGroups(new[] { nodePepGroupNew }, true,
toPath, out selectedPath, out nextAdd);
selectedPath = new IdentityPath(selectedPath, nodePepGroupNew.Children[0].Id);
return(document);
}
}
/// <summary>
/// Adds all peptides which can be matched to a background proteome to the
/// proteins in the background proteins, and returns a new document with those
/// proteins and peptides added.
/// </summary>
/// <param name="document">The starting document</param>
/// <param name="dictCopy">A dictionary of peptides to peptide matches. All added
/// peptides are removed</param>
/// <param name="broker">For reporting long wait status</param>
/// <param name="toPath">Path to the location in the document to add new items</param>
/// <param name="selectedPath">Path to item in the document that should be selected
/// after this operation is complete</param>
/// <returns>A new document with matching peptides and their proteins addded</returns>
private SrmDocument AddProteomePeptides(SrmDocument document,
Dictionary <PeptideSequenceModKey, PeptideMatch> dictCopy,
ILongWaitBroker broker,
IdentityPath toPath,
out IdentityPath selectedPath)
{
// Build a list of new PeptideGroupDocNodes to add to the document.
var dictPeptideGroupsNew = new Dictionary <string, PeptideGroupDocNode>();
// Get starting progress values
int startPercent = (broker != null ? broker.ProgressValue : 0);
int processedPercent = 0;
int processedCount = 0;
int totalMatches = dictCopy.Count;
// Just to make sure this is set
selectedPath = toPath;
foreach (PeptideMatch pepMatch in dictCopy.Values)
{
// Show progress, if in a long wait
if (broker != null)
{
if (broker.IsCanceled)
{
selectedPath = toPath;
return(document);
}
// All peptides with protein get processed in this loop. Peptides
// without proteins get added later.
if (pepMatch.Proteins != null)
{
processedCount++;
}
int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
if (processedPercent != processPercentNow)
{
processedPercent = processPercentNow;
broker.ProgressValue = startPercent + processedPercent;
}
}
// Peptide should be added to the document,
// unless the NoDuplicates radio was selected and the peptide has more than 1 protein associated with it.
if (pepMatch.Proteins == null ||
(FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.NoDuplicates && pepMatch.Proteins.Count > 1))
{
continue;
}
foreach (ProteinInfo protein in pepMatch.Proteins)
{
// Look for the protein in the document.
string name = protein.ProteinMetadata.Name;
var peptideGroupDocNode = FindPeptideGroupDocNode(document, name);
bool foundInDoc = peptideGroupDocNode != null;
bool foundInList = false;
if (!foundInDoc)
{
// If the protein is not already in the document,
// check to see if we have already created a PeptideGroupDocNode for it.
if (name != null && dictPeptideGroupsNew.TryGetValue(name, out peptideGroupDocNode))
{
foundInList = true;
}
// If not, create a new PeptideGroupDocNode.
else
{
List <ProteinMetadata> alternativeProteins = new List <ProteinMetadata>(protein.Alternatives);
peptideGroupDocNode = new PeptideGroupDocNode(
new FastaSequence(name, protein.ProteinMetadata.Description, alternativeProteins, protein.Sequence),
null, null, new PeptideDocNode[0]);
}
}
// Create a new peptide that matches this protein.
var fastaSequence = peptideGroupDocNode.PeptideGroup as FastaSequence;
var peptideSequence = pepMatch.NodePep.Peptide.Target.Sequence;
// ReSharper disable PossibleNullReferenceException
var begin = fastaSequence.Sequence.IndexOf(peptideSequence, StringComparison.Ordinal);
// ReSharper restore PossibleNullReferenceException
// Create a new PeptideDocNode using this peptide.
var newPeptide = new Peptide(fastaSequence, peptideSequence, begin, begin + peptideSequence.Length,
Settings.PeptideSettings.Enzyme.CountCleavagePoints(peptideSequence));
// Make sure we keep the same children.
PeptideMatch match = pepMatch;
var newNodePep = ((PeptideDocNode) new PeptideDocNode(newPeptide, pepMatch.NodePep.ExplicitMods, pepMatch.NodePep.ExplicitRetentionTime)
.ChangeChildren(pepMatch.NodePep.Children.ToList().ConvertAll(nodeGroup =>
{
// Create copies of the children in order to prevent transition groups with the same
// global indices.
var nodeTranGroup = (TransitionGroupDocNode)nodeGroup;
if (match.Proteins != null && match.Proteins.Count > 1)
{
nodeTranGroup = (TransitionGroupDocNode)nodeTranGroup.CopyId();
nodeTranGroup = (TransitionGroupDocNode)nodeTranGroup.ChangeChildren(
nodeTranGroup.Children.ToList().ConvertAll(nodeTran => nodeTran.CopyId()));
}
return((DocNode)nodeTranGroup);
})).ChangeAutoManageChildren(false)).ChangeSettings(document.Settings, SrmSettingsDiff.ALL);
// If this PeptideDocNode is already a child of the PeptideGroupDocNode,
// ignore it.
if (peptideGroupDocNode.Children.Contains(nodePep => Equals(((PeptideDocNode)nodePep).Key, newNodePep.Key)))
{
Console.WriteLine(Resources.ViewLibraryPepMatching_AddProteomePeptides_Skipping__0__already_present, newNodePep.Peptide.Target);
continue;
}
// Otherwise, add it to the list of children for the PeptideGroupNode.
var newChildren = peptideGroupDocNode.Children.Cast <PeptideDocNode>().ToList();
newChildren.Add(newNodePep);
newChildren.Sort(FastaSequence.ComparePeptides);
// Store modified proteins by global index in a HashSet for second pass.
var newPeptideGroupDocNode = peptideGroupDocNode.ChangeChildren(newChildren.Cast <DocNode>().ToArray())
.ChangeAutoManageChildren(false);
// If the protein was already in the document, replace with the new PeptideGroupDocNode.
if (foundInDoc)
{
document = (SrmDocument)document.ReplaceChild(newPeptideGroupDocNode);
}
// Otherwise, update the list of new PeptideGroupDocNodes to add.
else
{
if (foundInList)
{
dictPeptideGroupsNew.Remove(peptideGroupDocNode.Name);
}
dictPeptideGroupsNew.Add(peptideGroupDocNode.Name, (PeptideGroupDocNode)newPeptideGroupDocNode);
}
// If we are only adding a single node, select it.
if (PeptideMatches.Count == 1)
{
selectedPath = new IdentityPath(new[] { peptideGroupDocNode.Id, newNodePep.Peptide });
}
// If the user only wants to add the first protein found,
// we break the foreach loop after peptide has been added to its first protein.)
if (FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.FirstOccurence)
{
break;
}
}
}
if (dictPeptideGroupsNew.Count == 0)
{
return(document);
}
// Sort the peptides.
var nodePepGroupsSortedChildren = new List <PeptideGroupDocNode>();
foreach (PeptideGroupDocNode nodePepGroup in dictPeptideGroupsNew.Values)
{
var newChildren = nodePepGroup.Children.ToList();
// Have to cast all children to PeptideDocNodes in order to sort.
var newChildrenNodePeps = newChildren.Cast <PeptideDocNode>().ToList();
newChildrenNodePeps.Sort(FastaSequence.ComparePeptides);
nodePepGroupsSortedChildren.Add((PeptideGroupDocNode)
nodePepGroup.ChangeChildren(newChildrenNodePeps.Cast <DocNode>().ToArray()));
}
// Sort the proteins.
nodePepGroupsSortedChildren.Sort((node1, node2) => Comparer <string> .Default.Compare(node1.Name, node2.Name));
IdentityPath selPathTemp = selectedPath, nextAdd;
document = document.AddPeptideGroups(nodePepGroupsSortedChildren, false,
toPath, out selectedPath, out nextAdd);
selectedPath = PeptideMatches.Count == 1 ? selPathTemp : selectedPath;
return(document);
}
/// <summary>
/// Adds all peptides which can be matched to a background proteome to the
/// proteins in the background proteins, and returns a new document with those
/// proteins and peptides added.
/// </summary>
/// <param name="document">The starting document</param>
/// <param name="dictCopy">A dictionary of peptides to peptide matches. All added
/// peptides are removed</param>
/// <param name="broker">For reporting long wait status</param>
/// <param name="toPath">Path to the location in the document to add new items</param>
/// <param name="selectedPath">Path to item in the document that should be selected
/// after this operation is complete</param>
/// <returns>A new document with matching peptides and their proteins addded</returns>
private SrmDocument AddProteomePeptides(SrmDocument document,
Dictionary<PeptideSequenceModKey, PeptideMatch> dictCopy,
ILongWaitBroker broker,
IdentityPath toPath,
out IdentityPath selectedPath)
{
// Build a list of new PeptideGroupDocNodes to add to the document.
var dictPeptideGroupsNew = new Dictionary<string, PeptideGroupDocNode>();
// Get starting progress values
int startPercent = (broker != null ? broker.ProgressValue : 0);
int processedPercent = 0;
int processedCount = 0;
int totalMatches = dictCopy.Count;
// Just to make sure this is set
selectedPath = toPath;
foreach (PeptideMatch pepMatch in dictCopy.Values)
{
// Show progress, if in a long wait
if (broker != null)
{
if (broker.IsCanceled)
{
selectedPath = toPath;
return document;
}
// All peptides with protein get processed in this loop. Peptides
// without proteins get added later.
if (pepMatch.Proteins != null)
processedCount++;
int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
if (processedPercent != processPercentNow)
{
processedPercent = processPercentNow;
broker.ProgressValue = startPercent + processedPercent;
}
}
// Peptide should be added to the document,
// unless the NoDuplicates radio was selected and the peptide has more than 1 protein associated with it.
if (pepMatch.Proteins == null ||
(FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.NoDuplicates && pepMatch.Proteins.Count > 1))
continue;
foreach (ProteinInfo protein in pepMatch.Proteins)
{
// Look for the protein in the document.
string name = protein.ProteinMetadata.Name;
var peptideGroupDocNode = FindPeptideGroupDocNode(document, name);
bool foundInDoc = peptideGroupDocNode != null;
bool foundInList = false;
if (!foundInDoc)
{
// If the protein is not already in the document,
// check to see if we have already created a PeptideGroupDocNode for it.
if (dictPeptideGroupsNew.TryGetValue(name, out peptideGroupDocNode))
foundInList = true;
// If not, create a new PeptideGroupDocNode.
else
{
List<ProteinMetadata> alternativeProteins = new List<ProteinMetadata>(protein.Alternatives);
peptideGroupDocNode = new PeptideGroupDocNode(
new FastaSequence(name, protein.ProteinMetadata.Description, alternativeProteins, protein.Sequence),
null, null, new PeptideDocNode[0]);
}
}
// Create a new peptide that matches this protein.
var fastaSequence = peptideGroupDocNode.PeptideGroup as FastaSequence;
var peptideSequence = pepMatch.NodePep.Peptide.Sequence;
// ReSharper disable PossibleNullReferenceException
var begin = fastaSequence.Sequence.IndexOf(peptideSequence, StringComparison.Ordinal);
// ReSharper restore PossibleNullReferenceException
// Create a new PeptideDocNode using this peptide.
var newPeptide = new Peptide(fastaSequence, peptideSequence, begin, begin + peptideSequence.Length,
Settings.PeptideSettings.Enzyme.CountCleavagePoints(peptideSequence));
// Make sure we keep the same children.
PeptideMatch match = pepMatch;
var newNodePep = ((PeptideDocNode) new PeptideDocNode(newPeptide, pepMatch.NodePep.ExplicitMods, pepMatch.NodePep.ExplicitRetentionTime)
.ChangeChildren(pepMatch.NodePep.Children.ToList().ConvertAll(nodeGroup =>
{
// Create copies of the children in order to prevent transition groups with the same
// global indices.
var nodeTranGroup = (TransitionGroupDocNode) nodeGroup;
if(match.Proteins != null && match.Proteins.Count() > 1)
{
nodeTranGroup = (TransitionGroupDocNode) nodeTranGroup.CopyId();
nodeTranGroup = (TransitionGroupDocNode) nodeTranGroup.ChangeChildren(
nodeTranGroup.Children.ToList().ConvertAll(nodeTran => nodeTran.CopyId()));
}
return (DocNode) nodeTranGroup;
})).ChangeAutoManageChildren(false)).ChangeSettings(document.Settings, SrmSettingsDiff.ALL);
// If this PeptideDocNode is already a child of the PeptideGroupDocNode,
// ignore it.
if (peptideGroupDocNode.Children.Contains(nodePep => Equals(((PeptideDocNode) nodePep).Key, newNodePep.Key)))
{
Console.WriteLine(Resources.ViewLibraryPepMatching_AddProteomePeptides_Skipping__0__already_present, newNodePep.Peptide.Sequence);
continue;
}
// Otherwise, add it to the list of children for the PeptideGroupNode.
var newChildren = peptideGroupDocNode.Children.Cast<PeptideDocNode>().ToList();
newChildren.Add(newNodePep);
newChildren.Sort(FastaSequence.ComparePeptides);
// Store modified proteins by global index in a HashSet for second pass.
var newPeptideGroupDocNode = peptideGroupDocNode.ChangeChildren(newChildren.Cast<DocNode>().ToArray())
.ChangeAutoManageChildren(false);
// If the protein was already in the document, replace with the new PeptideGroupDocNode.
if (foundInDoc)
document = (SrmDocument)document.ReplaceChild(newPeptideGroupDocNode);
// Otherwise, update the list of new PeptideGroupDocNodes to add.
else
{
if (foundInList)
dictPeptideGroupsNew.Remove(peptideGroupDocNode.Name);
dictPeptideGroupsNew.Add(peptideGroupDocNode.Name, (PeptideGroupDocNode) newPeptideGroupDocNode);
}
// If we are only adding a single node, select it.
if (PeptideMatches.Count == 1)
selectedPath = new IdentityPath(new[] {peptideGroupDocNode.Id, newNodePep.Peptide});
// If the user only wants to add the first protein found,
// we break the foreach loop after peptide has been added to its first protein.)
if (FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.FirstOccurence)
break;
}
}
if (dictPeptideGroupsNew.Count == 0)
{
return document;
}
// Sort the peptides.
var nodePepGroupsSortedChildren = new List<PeptideGroupDocNode>();
foreach(PeptideGroupDocNode nodePepGroup in dictPeptideGroupsNew.Values)
{
var newChildren = nodePepGroup.Children.ToList();
// Have to cast all children to PeptideDocNodes in order to sort.
var newChildrenNodePeps = newChildren.Cast<PeptideDocNode>().ToList();
newChildrenNodePeps.Sort(FastaSequence.ComparePeptides);
nodePepGroupsSortedChildren.Add((PeptideGroupDocNode)
nodePepGroup.ChangeChildren(newChildrenNodePeps.Cast<DocNode>().ToArray()));
}
// Sort the proteins.
nodePepGroupsSortedChildren.Sort((node1, node2) => Comparer<string>.Default.Compare(node1.Name, node2.Name));
IdentityPath selPathTemp = selectedPath, nextAdd;
document = document.AddPeptideGroups(nodePepGroupsSortedChildren, false,
toPath, out selectedPath, out nextAdd);
selectedPath = PeptideMatches.Count == 1 ? selPathTemp : selectedPath;
return document;
}
private static SrmDocument AddPeptidesToLibraryGroup(SrmDocument document,
ICollection<PeptideMatch> listMatches,
ILongWaitBroker broker,
IdentityPath toPath,
out IdentityPath selectedPath)
{
// Get starting progress values
int startPercent = (broker != null ? broker.ProgressValue : 0);
int processedPercent = 0;
int processedCount = 0;
int totalMatches = listMatches.Count;
var listPeptides = new List<PeptideDocNode>();
foreach (var match in listMatches)
{
// Show progress, if in a long wait
if (broker != null)
{
if (broker.IsCanceled)
{
selectedPath = null;
return document;
}
processedCount++;
int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
if (processedPercent != processPercentNow)
{
processedPercent = processPercentNow;
broker.ProgressValue = startPercent + processedPercent;
}
}
listPeptides.Add(match.NodePep.ChangeSettings(document.Settings, SrmSettingsDiff.ALL));
}
bool hasVariable =
listPeptides.Contains(nodePep => nodePep.HasExplicitMods && nodePep.ExplicitMods.IsVariableStaticMods);
// Use existing group by this name, if present.
var nodePepGroupNew = FindPeptideGroupDocNode(document, Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Peptides);
if(nodePepGroupNew != null)
{
var newChildren = nodePepGroupNew.Children.ToList();
newChildren.AddRange(listPeptides.ConvertAll(nodePep => (DocNode) nodePep));
selectedPath = (listPeptides.Count == 1 ? new IdentityPath(nodePepGroupNew.Id, listPeptides[0].Id) : toPath);
nodePepGroupNew = (PeptideGroupDocNode) nodePepGroupNew.ChangeChildren(newChildren);
if (hasVariable)
nodePepGroupNew = (PeptideGroupDocNode) nodePepGroupNew.ChangeAutoManageChildren(false);
return (SrmDocument) document.ReplaceChild(nodePepGroupNew);
}
else
{
nodePepGroupNew = new PeptideGroupDocNode(new PeptideGroup(),
Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Peptides,
string.Empty, listPeptides.ToArray());
if (hasVariable)
nodePepGroupNew = (PeptideGroupDocNode) nodePepGroupNew.ChangeAutoManageChildren(false);
IdentityPath nextAdd;
document = document.AddPeptideGroups(new[] { nodePepGroupNew }, true,
toPath, out selectedPath, out nextAdd);
selectedPath = new IdentityPath(selectedPath, nodePepGroupNew.Children[0].Id);
return document;
}
}
private static SrmDocument AddPeptidesToLibraryGroup(SrmDocument document,
ICollection <PeptideMatch> listMatches,
ILongWaitBroker broker,
IdentityPath toPath,
out IdentityPath selectedPath)
{
// Get starting progress values
int startPercent = (broker != null ? broker.ProgressValue : 0);
int processedPercent = 0;
int processedCount = 0;
int totalMatches = listMatches.Count;
selectedPath = null;
// Some .blib files provide protein accessions (understood as Molecule List Names fro small molecules).
// If those are provided we will use them as node names.
// TODO(bspratt) for now we will do this only for small molecules since it might be a surprise to proteomics users. We should revisit that decision.
foreach (var proteinName in listMatches.Select(m => m.LibInfo.Protein).Distinct())
{
var listPeptides = new List <PeptideDocNode>();
var hasSmallMolecules = false;
foreach (var match in listMatches.Where(m => Equals(proteinName, m.LibInfo.Protein)))
{
// Show progress, if in a long wait
if (broker != null)
{
if (broker.IsCanceled)
{
selectedPath = null;
return(document);
}
processedCount++;
int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
if (processedPercent != processPercentNow)
{
processedPercent = processPercentNow;
broker.ProgressValue = startPercent + processedPercent;
}
}
listPeptides.Add(match.NodePep.ChangeSettings(document.Settings, SrmSettingsDiff.ALL));
hasSmallMolecules |= !match.NodePep.IsProteomic;
}
bool hasVariable =
listPeptides.Contains(nodePep => nodePep.HasExplicitMods && nodePep.ExplicitMods.IsVariableStaticMods);
// Use existing group by this name, if present.
// If library provides a RefSpectraProteins table, use that to name the group
// TODO(bspratt) for now we will use RefSpectraProteins names only for small molecules
var genericLibraryPeptidesGroupName = hasSmallMolecules
? Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Molecules
: Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Peptides;
var nodeName = string.IsNullOrEmpty(proteinName) ||
listPeptides.Any(p => p.IsProteomic) // TODO(bspratt) revisit this caution-driven decision
? genericLibraryPeptidesGroupName
: proteinName;
var nodePepGroupNew = FindPeptideGroupDocNode(document, nodeName, null);
if (nodePepGroupNew != null)
{
var newChildren = nodePepGroupNew.Children.ToList();
newChildren.AddRange(listPeptides.ConvertAll(nodePep => (DocNode)nodePep));
selectedPath = (listPeptides.Count == 1 ? new IdentityPath(nodePepGroupNew.Id, listPeptides[0].Id) : toPath);
nodePepGroupNew = (PeptideGroupDocNode)nodePepGroupNew.ChangeChildren(newChildren);
if (hasVariable)
{
nodePepGroupNew = (PeptideGroupDocNode)nodePepGroupNew.ChangeAutoManageChildren(false);
}
document = (SrmDocument)document.ReplaceChild(nodePepGroupNew);
}
else
{
nodePepGroupNew = new PeptideGroupDocNode(new PeptideGroup(),
nodeName,
string.Empty, listPeptides.ToArray());
if (hasVariable)
{
nodePepGroupNew = (PeptideGroupDocNode)nodePepGroupNew.ChangeAutoManageChildren(false);
}
IdentityPath nextAdd;
document = document.AddPeptideGroups(new[] { nodePepGroupNew }, true,
toPath, out selectedPath, out nextAdd);
selectedPath = new IdentityPath(selectedPath, nodePepGroupNew.Children[0].Id);
}
}
return(document);
}