protected override GraphData CreateGraphData(SrmDocument document, PeptideGroupDocNode selectedProtein, TransitionGroupDocNode selectedGroup, DisplayTypeChrom displayType)
{
int? result = null;
if (RTLinearRegressionGraphPane.ShowReplicate == ReplicateDisplay.single)
result = GraphSummary.ResultsIndex;
return new AreaGraphData(document, selectedGroup, selectedProtein, result, displayType, PaneKey);
}
protected override GraphData CreateGraphData(SrmDocument document, PeptideGroupDocNode selectedProtein, TransitionGroupDocNode selectedGroup, DisplayTypeChrom displayType)
{
int? result = null;
if (RTLinearRegressionGraphPane.ShowReplicate == ReplicateDisplay.single)
result = GraphSummary.ResultsIndex;
return new RTGraphData(document, selectedGroup, selectedProtein, result, displayType, GraphSummary.StateProvider.GetRetentionTimeTransformOperation());
}
public AreaGraphData(SrmDocument document,
TransitionGroupDocNode selectedGroup,
PeptideGroupDocNode selectedProtein,
int? result,
DisplayTypeChrom displayType,
PaneKey paneKey)
: base(document, selectedGroup, selectedProtein, result, displayType, null, paneKey)
{
}
public PeptideGroupDocNode Merge(PeptideGroupDocNode nodePepGroup)
{
var childrenNew = new List<PeptideDocNode>(Children.Cast<PeptideDocNode>());
// Remember where all the existing children are
var dictPepIndex = new Dictionary<PeptideModKey, int>();
for (int i = 0; i < childrenNew.Count; i++)
{
var key = childrenNew[i].Key;
if (!dictPepIndex.ContainsKey(key))
dictPepIndex[key] = i;
}
// Add the new children to the end, or merge when the peptide is already present
foreach (PeptideDocNode nodePep in nodePepGroup.Children)
{
int i;
if (dictPepIndex.TryGetValue(nodePep.Key, out i))
childrenNew[i] = childrenNew[i].Merge(nodePep);
else
childrenNew.Add(nodePep);
}
// If it is a FASTA sequence, make sure new peptides are sorted into place
if (PeptideGroup is FastaSequence && childrenNew.Count > Children.Count)
childrenNew.Sort(FastaSequence.ComparePeptides);
return (PeptideGroupDocNode) ChangeChildrenChecked(childrenNew.Cast<DocNode>().ToArray());
}
public static int CompareNames(PeptideGroupDocNode p1, PeptideGroupDocNode p2)
{
return(string.Compare(p1.Name, p2.Name, StringComparison.CurrentCulture));
}
public RTGraphData(SrmDocument document,
TransitionGroupDocNode selectedGroup,
PeptideGroupDocNode selectedProtein,
int? result,
DisplayTypeChrom displayType,
GraphValues.IRetentionTimeTransformOp retentionTimeTransformOp
)
: base(document, selectedGroup, selectedProtein, result, displayType, retentionTimeTransformOp, PaneKey.DEFAULT)
{
}
public static int CompareAccessions(PeptideGroupDocNode p1, PeptideGroupDocNode p2)
{
return(string.Compare(p1.ProteinMetadata.Accession ?? String.Empty, p2.ProteinMetadata.Accession ?? String.Empty, StringComparison.InvariantCultureIgnoreCase));
}
private static int CompareNames(PeptideGroupDocNode group1, PeptideGroupDocNode group2)
{
return String.Compare(group1.Name, group2.Name, CultureInfo.CurrentCulture, CompareOptions.None);
}
private SrmDocument AddProteins(SrmDocument document, ref IdentityPath selectedPath)
{
if (tabControl1.SelectedTab != tabPageProteinList)
return document;
var backgroundProteome = GetBackgroundProteome(document);
for (int i = gridViewProteins.Rows.Count - 1; i >= 0; i--)
{
var row = gridViewProteins.Rows[i];
var proteinName = Convert.ToString(row.Cells[colProteinName.Index].Value);
if (String.IsNullOrEmpty(proteinName))
{
continue;
}
var pastedMetadata = new ProteinMetadata(proteinName,
Convert.ToString(row.Cells[colProteinDescription.Index].Value),
NullForEmpty(Convert.ToString(row.Cells[colProteinPreferredName.Index].Value)),
NullForEmpty(Convert.ToString(row.Cells[colProteinAccession.Index].Value)),
NullForEmpty(Convert.ToString(row.Cells[colProteinGene.Index].Value)),
NullForEmpty(Convert.ToString(row.Cells[colProteinSpecies.Index].Value)));
FastaSequence fastaSequence = null;
if (!backgroundProteome.IsNone)
{
ProteinMetadata protdbMetadata;
fastaSequence = backgroundProteome.GetFastaSequence(proteinName, out protdbMetadata);
// Fill in any gaps in pasted metadata with that in protdb
pastedMetadata = pastedMetadata.Merge(protdbMetadata);
}
// Strip any whitespace (tab, newline etc) In case it was copied out of a FASTA file
var fastaSequenceString = new string(Convert.ToString(row.Cells[colProteinSequence.Index].Value).Where(c => !Char.IsWhiteSpace(c)).ToArray());
if (!string.IsNullOrEmpty(fastaSequenceString))
{
try
{
if (fastaSequence == null) // Didn't match anything in protdb
{
fastaSequence = new FastaSequence(pastedMetadata.Name, pastedMetadata.Description,
new ProteinMetadata[0], fastaSequenceString);
}
else
{
if (fastaSequence.Sequence != fastaSequenceString)
{
fastaSequence = new FastaSequence(pastedMetadata.Name, pastedMetadata.Description,
fastaSequence.Alternatives, fastaSequenceString);
}
}
}
catch (Exception exception)
{
ShowProteinError(new PasteError
{
Line = i,
Column = colProteinDescription.Index,
Message = string.Format(Resources.PasteDlg_AddProteins_Invalid_protein_sequence__0__, exception.Message)
});
return null;
}
}
if (fastaSequence == null)
{
ShowProteinError(
new PasteError
{
Line = i,
Message = backgroundProteome.IsNone
? Resources.PasteDlg_AddProteins_Missing_protein_sequence
: Resources.PasteDlg_AddProteins_This_protein_was_not_found_in_the_background_proteome_database
});
return null;
}
var description = pastedMetadata.Description;
if (!string.IsNullOrEmpty(description) && description != fastaSequence.Description)
{
fastaSequence = new FastaSequence(fastaSequence.Name, description, fastaSequence.Alternatives, fastaSequence.Sequence);
}
pastedMetadata = pastedMetadata.ChangeName(fastaSequence.Name).ChangeDescription(fastaSequence.Description); // Make sure these agree
var nodeGroupPep = new PeptideGroupDocNode(fastaSequence, pastedMetadata, new PeptideDocNode[0]);
nodeGroupPep = nodeGroupPep.ChangeSettings(document.Settings, SrmSettingsDiff.ALL);
var to = selectedPath;
if (to == null || to.Depth < (int)SrmDocument.Level.MoleculeGroups)
document = (SrmDocument)document.Add(nodeGroupPep);
else
{
Identity toId = selectedPath.GetIdentity((int)SrmDocument.Level.MoleculeGroups);
document = (SrmDocument)document.Insert(toId, nodeGroupPep);
}
selectedPath = new IdentityPath(nodeGroupPep.Id);
}
return document;
}
private static bool IsPeptideListDocNode(PeptideGroupDocNode peptideGroupDocNode)
{
return peptideGroupDocNode != null && peptideGroupDocNode.IsPeptideList;
}
public SrmDocument ConvertToSmallMolecules(SrmDocument document,
ConvertToSmallMoleculesMode mode = ConvertToSmallMoleculesMode.formulas,
bool invertCharges = false,
bool ignoreDecoys=false)
{
if (mode == ConvertToSmallMoleculesMode.none)
return document;
var newdoc = new SrmDocument(document.Settings);
var note = new Annotations(TestingConvertedFromProteomic, null, 1); // Mark this as a testing node so we don't sort it
newdoc = (SrmDocument)newdoc.ChangeIgnoreChangingChildren(true); // Retain copied results
foreach (var peptideGroupDocNode in document.MoleculeGroups)
{
if (!peptideGroupDocNode.IsProteomic)
{
newdoc = (SrmDocument)newdoc.Add(peptideGroupDocNode); // Already a small molecule
}
else
{
var newPeptideGroup = new PeptideGroup();
var newPeptideGroupDocNode = new PeptideGroupDocNode(newPeptideGroup,
peptideGroupDocNode.Annotations.Merge(note), peptideGroupDocNode.Name,
peptideGroupDocNode.Description, new PeptideDocNode[0],
peptideGroupDocNode.AutoManageChildren);
foreach (var mol in peptideGroupDocNode.Molecules)
{
var peptideSequence = mol.Peptide.Sequence;
// Create a PeptideDocNode with the presumably baseline charge and label
var precursorCharge = (mol.TransitionGroups.Any() ? mol.TransitionGroups.First().TransitionGroup.PrecursorCharge : 0) * (invertCharges ? -1 : 1);
var isotopeLabelType = mol.TransitionGroups.Any() ? mol.TransitionGroups.First().TransitionGroup.LabelType : IsotopeLabelType.light;
var moleculeCustomIon = ConvertToSmallMolecule(mode, document, mol, precursorCharge, isotopeLabelType);
var precursorCustomIon = moleculeCustomIon;
var newPeptide = new Peptide(moleculeCustomIon);
var newPeptideDocNode = new PeptideDocNode(newPeptide, newdoc.Settings, null, null,
null, null, mol.ExplicitRetentionTime, note, mol.Results, new TransitionGroupDocNode[0],
mol.AutoManageChildren);
foreach (var transitionGroupDocNode in mol.TransitionGroups)
{
if (transitionGroupDocNode.IsDecoy)
{
if (ignoreDecoys)
continue;
throw new Exception("There is no translation from decoy to small molecules"); // Not L10N
}
if (transitionGroupDocNode.TransitionGroup.PrecursorCharge != Math.Abs(precursorCharge) ||
!Equals(isotopeLabelType, transitionGroupDocNode.TransitionGroup.LabelType))
{
// Different charges or labels mean different ion formulas
precursorCharge = transitionGroupDocNode.TransitionGroup.PrecursorCharge * (invertCharges ? -1 : 1);
isotopeLabelType = transitionGroupDocNode.TransitionGroup.LabelType;
precursorCustomIon = ConvertToSmallMolecule(mode, document, mol, precursorCharge, isotopeLabelType);
}
var newTransitionGroup = new TransitionGroup(newPeptide, precursorCustomIon, precursorCharge, isotopeLabelType);
// Remove any library info, since for the moment at least small molecules don't support this and it won't roundtrip
var resultsNew = RemoveTransitionGroupChromInfoLibraryInfo(transitionGroupDocNode);
var newTransitionGroupDocNode = new TransitionGroupDocNode(newTransitionGroup,
transitionGroupDocNode.Annotations.Merge(note), document.Settings,
null, null, transitionGroupDocNode.ExplicitValues, resultsNew, null,
transitionGroupDocNode.AutoManageChildren);
var mzShift = invertCharges ? 2.0 * BioMassCalc.MassProton : 0; // We removed hydrogen rather than added
Assume.IsTrue((Math.Abs(newTransitionGroupDocNode.PrecursorMz + mzShift - transitionGroupDocNode.PrecursorMz) - Math.Abs(transitionGroupDocNode.TransitionGroup.PrecursorCharge * BioMassCalc.MassElectron)) <= 1E-5);
foreach (var transition in transitionGroupDocNode.Transitions)
{
double mass = 0;
var transitionCharge = transition.Transition.Charge * (invertCharges ? -1 : 1);
var ionType = IonType.custom;
CustomIon transitionCustomIon;
double mzShiftTransition = 0;
if (transition.Transition.IonType == IonType.precursor)
{
ionType = IonType.precursor;
transitionCustomIon = new DocNodeCustomIon(precursorCustomIon.Formula,
string.IsNullOrEmpty(precursorCustomIon.Formula) ? precursorCustomIon.MonoisotopicMass : (double?) null,
string.IsNullOrEmpty(precursorCustomIon.Formula) ? precursorCustomIon.AverageMass : (double?) null,
SmallMoleculeNameFromPeptide(peptideSequence, transitionCharge));
mzShiftTransition = invertCharges ? 2.0 * BioMassCalc.MassProton : 0; // We removed hydrogen rather than added
}
else if (transition.Transition.IonType == IonType.custom)
{
transitionCustomIon = transition.Transition.CustomIon;
mass = transitionCustomIon.MonoisotopicMass;
}
else
{
// TODO - try to get fragment formula?
mass = BioMassCalc.CalculateIonMassFromMz(transition.Mz, transition.Transition.Charge);
transitionCustomIon = new DocNodeCustomIon(mass, mass,// We can't really get at mono vs average mass from m/z, but for test purposes this is fine
transition.Transition.FragmentIonName);
}
if (mode == ConvertToSmallMoleculesMode.masses_and_names)
{
// Discard the formula if we're testing the use of mass-with-names (for matching in ratio calcs) target specification
transitionCustomIon = new DocNodeCustomIon(transitionCustomIon.MonoisotopicMass, transitionCustomIon.AverageMass,
transition.Transition.FragmentIonName);
}
else if (mode == ConvertToSmallMoleculesMode.masses_only)
{
// Discard the formula and name if we're testing the use of mass-only target specification
transitionCustomIon = new DocNodeCustomIon(transitionCustomIon.MonoisotopicMass, transitionCustomIon.AverageMass);
}
var newTransition = new Transition(newTransitionGroup, ionType,
null, transition.Transition.MassIndex, transition.Transition.Charge * (invertCharges ? -1 : 1), null,
transitionCustomIon);
if (ionType == IonType.precursor)
{
mass = document.Settings.GetFragmentMass(transitionGroupDocNode.TransitionGroup.LabelType, null, newTransition, newTransitionGroupDocNode.IsotopeDist);
}
var newTransitionDocNode = new TransitionDocNode(newTransition, transition.Annotations.Merge(note),
null, mass, transition.IsotopeDistInfo, null,
transition.Results);
Assume.IsTrue((Math.Abs(newTransitionDocNode.Mz + mzShiftTransition - transition.Mz) - Math.Abs(transitionGroupDocNode.TransitionGroup.PrecursorCharge * BioMassCalc.MassElectron)) <= 1E-5, String.Format("unexpected mz difference {0}-{1}={2}", newTransitionDocNode.Mz , transition.Mz, newTransitionDocNode.Mz - transition.Mz)); // Not L10N
newTransitionGroupDocNode =
(TransitionGroupDocNode)newTransitionGroupDocNode.Add(newTransitionDocNode);
}
if (newPeptideDocNode != null)
newPeptideDocNode = (PeptideDocNode)newPeptideDocNode.Add(newTransitionGroupDocNode);
}
newPeptideGroupDocNode =
(PeptideGroupDocNode)newPeptideGroupDocNode.Add(newPeptideDocNode);
}
newdoc = (SrmDocument)newdoc.Add(newPeptideGroupDocNode);
}
}
// No retention time prediction for small molecules (yet?)
newdoc = newdoc.ChangeSettings(newdoc.Settings.ChangePeptideSettings(newdoc.Settings.PeptideSettings.ChangePrediction(
newdoc.Settings.PeptideSettings.Prediction.ChangeRetentionTime(null))));
return newdoc;
}
private string GetAcceptProteinKey(PeptideGroupDocNode nodePepGroup)
{
switch (AcceptProteinType)
{
case ProteinSpecType.accession:
return nodePepGroup.ProteinMetadata.Accession;
case ProteinSpecType.preferred:
return nodePepGroup.ProteinMetadata.PreferredName;
}
return nodePepGroup.Name;
}
public bool Equals(PeptideGroupDocNode obj)
{
if (ReferenceEquals(null, obj)) return false;
if (ReferenceEquals(this, obj)) return true;
return base.Equals(obj) && Equals(obj._proteinMetadata, _proteinMetadata);
}
public static int ComparePreferredNames(PeptideGroupDocNode p1, PeptideGroupDocNode p2)
{
return string.Compare(p1.ProteinMetadata.PreferredName ?? String.Empty, p2.ProteinMetadata.PreferredName ?? String.Empty, StringComparison.InvariantCultureIgnoreCase);
}
public static int CompareNames(PeptideGroupDocNode p1, PeptideGroupDocNode p2)
{
return string.Compare(p1.Name, p2.Name, StringComparison.CurrentCulture);
}
public static int CompareAccessions(PeptideGroupDocNode p1, PeptideGroupDocNode p2)
{
return string.Compare(p1.ProteinMetadata.Accession ?? String.Empty, p2.ProteinMetadata.Accession ?? String.Empty, StringComparison.InvariantCultureIgnoreCase);
}
private PeptideGroupDocNode ExcludePeptides(PeptideGroupDocNode peptideGroupDocNode)
{
HashSet<PeptideDocNode> excludedPeptides = new HashSet<PeptideDocNode>();
for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
var row = dataGridView1.Rows[i];
if (!(bool) row.Cells[PeptideIncludedColumn.Name].Value)
{
excludedPeptides.Add((PeptideDocNode) row.Tag);
}
}
List<PeptideDocNode> children = new List<PeptideDocNode>();
foreach (PeptideDocNode child in peptideGroupDocNode.Children)
{
if (excludedPeptides.Contains(child))
{
continue;
}
children.Add(child);
}
return new PeptideGroupDocNode(
peptideGroupDocNode.PeptideGroup,
peptideGroupDocNode.Annotations,
peptideGroupDocNode.ProteinMetadata,
children.ToArray(),
false);
}
private static SrmDocument GenerateDecoysFunc(SrmDocument document, int numDecoys, bool multiCycle,
Func<SequenceMods, SequenceMods> genDecoySequence)
{
// Loop through the existing tree in random order creating decoys
var settings = document.Settings;
var enzyme = settings.PeptideSettings.Enzyme;
var decoyNodePepList = new List<PeptideDocNode>();
var setDecoyKeys = new HashSet<PeptideModKey>();
while (numDecoys > 0)
{
int startDecoys = numDecoys;
foreach (var nodePep in document.Peptides.ToArray().RandomOrder())
{
if (numDecoys == 0)
break;
// Decoys should not be based on standard peptides
if (nodePep.GlobalStandardType != null)
continue;
// If the non-terminal end of the peptide sequence is all a single character, skip this peptide,
// since it can't support decoy generation.
var sequence = nodePep.Peptide.Sequence;
if (genDecoySequence != null && sequence.Substring(0, sequence.Length - 1).Distinct().Count() == 1)
continue;
var seqMods = new SequenceMods(nodePep);
if (genDecoySequence != null)
{
seqMods = genDecoySequence(seqMods);
}
var peptide = nodePep.Peptide;
var decoyPeptide = new Peptide(null, seqMods.Sequence, null, null, enzyme.CountCleavagePoints(seqMods.Sequence), true);
if (seqMods.Mods != null)
seqMods.Mods = seqMods.Mods.ChangePeptide(decoyPeptide);
foreach (var comparableGroups in PeakFeatureEnumerator.ComparableGroups(nodePep))
{
var decoyNodeTranGroupList = GetDecoyGroups(nodePep, decoyPeptide, seqMods.Mods, comparableGroups, document,
Equals(seqMods.Sequence, peptide.Sequence));
if (decoyNodeTranGroupList.Count == 0)
continue;
var nodePepNew = new PeptideDocNode(decoyPeptide, settings, seqMods.Mods,
null, nodePep.ExplicitRetentionTime, decoyNodeTranGroupList.ToArray(), false);
if (!Equals(nodePep.ModifiedSequence, nodePepNew.ModifiedSequence))
{
var sourceKey = new ModifiedSequenceMods(nodePep.ModifiedSequence, nodePep.ExplicitMods);
nodePepNew = nodePepNew.ChangeSourceKey(sourceKey);
}
// Avoid adding duplicate peptides
if (setDecoyKeys.Contains(nodePepNew.Key))
continue;
setDecoyKeys.Add(nodePepNew.Key);
decoyNodePepList.Add(nodePepNew);
numDecoys--;
}
}
// Stop if not multi-cycle or the number of decoys has not changed.
if (!multiCycle || startDecoys == numDecoys)
break;
}
var decoyNodePepGroup = new PeptideGroupDocNode(new PeptideGroup(true), Annotations.EMPTY, PeptideGroup.DECOYS,
null, decoyNodePepList.ToArray(), false);
decoyNodePepGroup = decoyNodePepGroup.ChangeSettings(document.Settings, SrmSettingsDiff.ALL);
return (SrmDocument)document.Add(decoyNodePepGroup);
}
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 PeptideGroupDocNode Refine(PeptideGroupDocNode nodePepGroup,
SrmDocument document,
ICollection<int> outlierIds,
ICollection<RefinementIdentity> includedPeptides,
ICollection<RefinementIdentity> repeatedPeptides,
Dictionary<RefinementIdentity, List<int>> acceptedPeptides,
SrmSettingsChangeMonitor progressMonitor)
{
var listPeptides = new List<PeptideDocNode>();
int minPrecursors = MinPrecursorsPerPeptide ?? 0;
foreach (PeptideDocNode nodePep in nodePepGroup.Children)
{
if (progressMonitor != null)
progressMonitor.ProcessMolecule(nodePep);
if (outlierIds.Contains(nodePep.Id.GlobalIndex))
continue;
// If there is a set of accepted peptides, and this is not one of them
// then skip it.
List<int> acceptedCharges = null;
if (acceptedPeptides != null &&
!acceptedPeptides.TryGetValue(AcceptModified ? new RefinementIdentity(nodePep.RawTextId) : new RefinementIdentity(nodePep.RawUnmodifiedTextId), out acceptedCharges))
{
continue;
}
int bestResultIndex = (UseBestResult ? nodePep.BestResult : -1);
float? peakFoundRatio = nodePep.GetPeakCountRatio(bestResultIndex);
if (!peakFoundRatio.HasValue)
{
if (RemoveMissingResults)
continue;
}
else
{
if (MinPeakFoundRatio.HasValue)
{
if (peakFoundRatio < MinPeakFoundRatio.Value)
continue;
}
if (MaxPeakFoundRatio.HasValue)
{
if (peakFoundRatio > MaxPeakFoundRatio.Value)
continue;
}
}
PeptideDocNode nodePepRefined = nodePep;
if (AutoPickPrecursorsAll && nodePep.AutoManageChildren == AutoPickChildrenOff)
{
nodePepRefined = (PeptideDocNode) nodePepRefined.ChangeAutoManageChildren(!AutoPickChildrenOff);
var settings = document.Settings;
if (!settings.TransitionSettings.Filter.AutoSelect && !AutoPickChildrenOff)
settings = settings.ChangeTransitionFilter(filter => filter.ChangeAutoSelect(!AutoPickChildrenOff));
nodePepRefined = nodePepRefined.ChangeSettings(settings,
new SrmSettingsDiff(false, false, true, false, AutoPickTransitionsAll, false));
}
nodePepRefined = Refine(nodePepRefined, document, bestResultIndex, acceptedCharges);
// Always remove peptides if all precursors have been removed by refinement
if (!ReferenceEquals(nodePep, nodePepRefined) && nodePepRefined.Children.Count == 0)
continue;
if (nodePepRefined.Children.Count < minPrecursors)
continue;
if (includedPeptides != null)
{
var identity = nodePepRefined.Peptide.IsCustomIon
? new RefinementIdentity(nodePep.Peptide.CustomIon)
: new RefinementIdentity(document.Settings.GetModifiedSequence(nodePepRefined));
// Skip peptides already added
if (includedPeptides.Contains(identity))
{
// Record repeated peptides for removing duplicate peptides later
if (repeatedPeptides != null)
repeatedPeptides.Add(identity);
continue;
}
// Record all peptides seen
includedPeptides.Add(identity);
}
listPeptides.Add(nodePepRefined);
}
if (MaxPepPeakRank.HasValue)
{
// Calculate the average peak area for each peptide
int countPeps = listPeptides.Count;
var listAreaIndexes = new List<PepAreaSortInfo>();
var internalStandardTypes = document.Settings.PeptideSettings.Modifications.InternalStandardTypes;
for (int i = 0; i < countPeps; i++)
{
var nodePep = listPeptides[i];
// Only peptides with children can possible be ranked by area
// Those without should be removed by this operation
if (nodePep.Children.Count == 0)
continue;
int bestResultIndex = (UseBestResult ? nodePep.BestResult : -1);
var sortInfo = new PepAreaSortInfo(nodePep, internalStandardTypes, bestResultIndex, listAreaIndexes.Count);
listAreaIndexes.Add(sortInfo);
}
listAreaIndexes.Sort((p1, p2) => Comparer.Default.Compare(p2.Area, p1.Area));
// Store area ranks
var arrayAreaIndexes = new PepAreaSortInfo[listAreaIndexes.Count];
int iRank = 1;
foreach (var areaIndex in listAreaIndexes)
{
areaIndex.Rank = iRank++;
arrayAreaIndexes[areaIndex.Index] = areaIndex;
}
// Add back all peptides with low enough rank.
listPeptides.Clear();
foreach (var areaIndex in arrayAreaIndexes)
{
if (areaIndex.Area == 0 || areaIndex.Rank > MaxPepPeakRank.Value)
continue;
listPeptides.Add(areaIndex.Peptide);
}
}
// Change the children, but only change auto-management, if the child
// identities have changed, not if their contents changed.
var childrenNew = listPeptides.ToArray();
bool updateAutoManage = !PeptideGroupDocNode.AreEquivalentChildren(nodePepGroup.Children, childrenNew);
return (PeptideGroupDocNode)nodePepGroup.ChangeChildrenChecked(childrenNew, updateAutoManage);
}
/// <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 PeptideGroupDocNode FindPeptideGroupDocNode(SrmDocument document, PeptideGroupDocNode nodePepGroup)
{
if (!nodePepGroup.IsPeptideList)
return (PeptideGroupDocNode) document.FindNode(nodePepGroup.PeptideGroup);
// Find peptide lists by name
return FindPeptideGroupDocNode(document, nodePepGroup.Name);
}
public static string ProteinModalDisplayText(PeptideGroupDocNode node)
{
return ProteinModalDisplayText(node.ProteinMetadata, Settings.Default.ShowPeptidesDisplayMode);
}
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;
}
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; // Not L10N
#endregion Fields
#region Constructors
// ReSharper restore SuggestBaseTypeForParameter
// ReSharper disable SuggestBaseTypeForParameter
public PeptideGroupTreeNode(SequenceTree tree, PeptideGroupDocNode group)
: base(tree, group)
{
}
protected abstract GraphData CreateGraphData(SrmDocument document, PeptideGroupDocNode selectedProtein,
TransitionGroupDocNode selectedGroup, DisplayTypeChrom displayType);
protected GraphData(SrmDocument document, TransitionGroupDocNode selectedGroup, PeptideGroupDocNode selectedProtein,
int? iResult, DisplayTypeChrom displayType, GraphValues.IRetentionTimeTransformOp retentionTimeTransformOp,
PaneKey paneKey)
{
RetentionTimeTransformOp = retentionTimeTransformOp;
// Determine the shortest possible unique ID for each peptide or molecule
var sequences = new List<Tuple<string, bool>>();
foreach (var nodePep in document.Molecules)
sequences.Add(new Tuple<string, bool>(nodePep.RawTextId, nodePep.IsProteomic));
var uniquePrefixGenerator = new UniquePrefixGenerator(sequences, 3);
int pointListCount = 0;
var dictTypeToSet = new Dictionary<IsotopeLabelType, int>();
bool onePointPerPeptide = PeptideOrder == SummaryPeptideOrder.document &&
null != paneKey.IsotopeLabelType;
// Figure out how many point lists to create
bool displayTotals = (displayType == DisplayTypeChrom.total);
if (displayTotals)
{
foreach (var nodeGroup in document.MoleculeTransitionGroups)
{
if (!paneKey.IncludesTransitionGroup(nodeGroup))
{
continue;
}
IsotopeLabelType labelType = nodeGroup.TransitionGroup.LabelType;
if (!dictTypeToSet.ContainsKey(labelType))
dictTypeToSet.Add(labelType, pointListCount++);
}
}
else
{
foreach (var nodeGroup in document.MoleculeTransitionGroups)
{
if (!paneKey.IncludesTransitionGroup(nodeGroup))
{
continue;
}
pointListCount = Math.Max(pointListCount, GraphChromatogram.GetDisplayTransitions(nodeGroup, displayType).Count());
}
}
// Build the list of points to show.
var listPoints = new List<GraphPointData>();
foreach (PeptideGroupDocNode nodeGroupPep in document.MoleculeGroups)
{
if (AreaGraphController.AreaScope == AreaScope.protein)
{
if (!ReferenceEquals(nodeGroupPep, selectedProtein))
continue;
}
foreach (PeptideDocNode nodePep in nodeGroupPep.Children)
{
bool addBlankPoint = onePointPerPeptide &&
!nodePep.TransitionGroups.Any(paneKey.IncludesTransitionGroup);
foreach (TransitionGroupDocNode nodeGroup in nodePep.Children)
{
var path = new IdentityPath(nodeGroupPep.PeptideGroup,
nodePep.Peptide, nodeGroup.TransitionGroup);
var graphPointData = new GraphPointData(nodePep, nodeGroup, path);
if (addBlankPoint || paneKey.IncludesTransitionGroup(nodeGroup))
{
listPoints.Add(graphPointData);
}
if (addBlankPoint)
{
break;
}
}
}
}
// Sort into correct order
var peptideOrder = PeptideOrder;
if (peptideOrder == SummaryPeptideOrder.time)
{
if (displayTotals)
listPoints.Sort(ComparePeptideTimes);
else
listPoints.Sort(CompareGroupTimes);
}
else if (peptideOrder == SummaryPeptideOrder.area)
{
listPoints.Sort(CompareGroupAreas);
}
// Init calculated values
var pointPairLists = new List<PointPairList>();
var labels = new List<string>();
var xscalePaths = new List<IdentityPath>();
double maxY = 0;
double minY = double.MaxValue;
int selectedIndex = -1;
for (int i = 0; i < pointListCount; i++)
pointPairLists.Add(new PointPairList());
// Calculate lists and values
PeptideDocNode nodePepCurrent = null;
int chargeCount = 0, chargeCurrent = 0;
foreach (var dataPoint in listPoints)
{
var nodePep = dataPoint.NodePep;
var nodeGroup = dataPoint.NodeGroup;
if (!ReferenceEquals(nodePep, nodePepCurrent))
{
nodePepCurrent = nodePep;
chargeCount = GetChargeCount(nodePep);
chargeCurrent = 0;
}
bool addLabel = !displayTotals;
if (displayTotals && nodeGroup.TransitionGroup.PrecursorCharge != chargeCurrent)
{
LevelPointPairLists(pointPairLists);
addLabel = true;
}
chargeCurrent = nodeGroup.TransitionGroup.PrecursorCharge;
var transitionGroup = nodeGroup.TransitionGroup;
int iGroup = labels.Count;
if (addLabel)
{
string label = uniquePrefixGenerator.GetUniquePrefix(nodePep.RawTextId, nodePep.IsProteomic) +
(chargeCount > 1
? Transition.GetChargeIndicator(transitionGroup.PrecursorCharge)
: string.Empty);
if (!displayTotals && null == paneKey.IsotopeLabelType)
label += transitionGroup.LabelTypeText;
if (peptideOrder == SummaryPeptideOrder.time)
{
label += string.Format(" ({0:F01})", displayTotals ? // Not L10N
dataPoint.TimePepCharge : dataPoint.TimeGroup);
}
labels.Add(label);
xscalePaths.Add(dataPoint.IdentityPath);
}
double groupMaxY = 0;
double groupMinY = double.MaxValue;
// ReSharper disable DoNotCallOverridableMethodsInConstructor
int? resultIndex = iResult.HasValue && iResult >= 0 ? iResult : null;
if (RTLinearRegressionGraphPane.ShowReplicate == ReplicateDisplay.best && nodePep != null)
{
resultIndex = null;
int iBest = nodePep.BestResult;
if (iBest !=-1)
resultIndex = iBest;
}
if (displayTotals)
{
var labelType = nodeGroup.TransitionGroup.LabelType;
if (dictTypeToSet.ContainsKey(labelType))
{
if (paneKey.IncludesTransitionGroup(nodeGroup))
{
pointPairLists[dictTypeToSet[labelType]].Add(CreatePointPair(iGroup, nodeGroup,
ref groupMaxY, ref groupMinY,
resultIndex));
}
else
{
pointPairLists[dictTypeToSet[labelType]].Add(PointPairMissing(iGroup));
}
}
}
else
{
if (paneKey.IncludesTransitionGroup(nodeGroup))
{
var nodeTrans = GraphChromatogram.GetDisplayTransitions(nodeGroup, displayType).ToArray();
for (int i = 0; i < pointListCount; i++)
{
var pointPairList = pointPairLists[i];
pointPairList.Add(i >= nodeTrans.Length
? CreatePointPairMissing(iGroup)
: CreatePointPair(iGroup, nodeTrans[i], ref groupMaxY,
ref groupMinY,
resultIndex));
}
}
else
{
for (int i = 0; i < pointListCount; i++)
{
pointPairLists[i].Add(CreatePointPairMissing(iGroup));
}
}
}
// ReSharper restore DoNotCallOverridableMethodsInConstructor
// Save the selected index and its y extent
if (ReferenceEquals(selectedGroup, nodeGroup))
{
selectedIndex = labels.Count - 1;
SelectedMaxY = groupMaxY;
SelectedMinY = groupMinY;
}
// If multiple groups in the selection, make sure y extent is max of them
else if (selectedIndex == labels.Count - 1)
{
SelectedMaxY = Math.Max(groupMaxY, SelectedMaxY);
SelectedMinY = Math.Min(groupMinY, SelectedMinY);
}
maxY = Math.Max(maxY, groupMaxY);
minY = Math.Min(minY, groupMinY);
}
PointPairLists = pointPairLists;
Labels = labels.ToArray();
XScalePaths = xscalePaths.ToArray();
SelectedIndex = selectedIndex;
MaxY = maxY;
if (minY != double.MaxValue)
MinY = minY;
}
private static bool ContainsCommonIrts(PeptideGroupDocNode protein)
{
return protein.Peptides.Select(pep => pep.ModifiedSequence).Intersect(COMMON_IRT_STANDARDS).Count() > CalibrateIrtDlg.MIN_STANDARD_PEPTIDES;
}
public PeptideGroupDocNode ToDocNode()
{
PeptideGroupDocNode nodePepGroup;
SrmSettingsDiff diff = SrmSettingsDiff.ALL;
if (PeptideList)
{
if (_activePeptide != null)
{
CompletePeptide(true);
diff = SrmSettingsDiff.PROPS;
}
nodePepGroup = new PeptideGroupDocNode(_activeFastaSeq ?? new PeptideGroup(_peptides.Any(p => p.IsDecoy)),
Name, Description, _peptides.ToArray());
}
else if (_customName) // name travels in the PeptideGroupDocNode instead of the FastaSequence
{
nodePepGroup = new PeptideGroupDocNode(
new FastaSequence(null, null, Alternatives, _sequence.ToString()),
Name, Description, new PeptideDocNode[0]);
}
else // name travels with the FastaSequence
{
nodePepGroup = new PeptideGroupDocNode(
new FastaSequence(Name, Description, Alternatives, _sequence.ToString()),
null, null, new PeptideDocNode[0]);
}
// If this is a fasta file with no explicitly modified peptides, then apply
// the usual peptide filtering rules. Otherwise, keep all peptides the user input.
if (!_autoManageChildren)
nodePepGroup = (PeptideGroupDocNode) nodePepGroup.ChangeAutoManageChildren(false);
// Materialize children, so that we have accurate accounting of
// peptide and transition counts.
nodePepGroup = nodePepGroup.ChangeSettings(_settings, diff);
List<DocNode> newChildren = new List<DocNode>();
foreach (PeptideDocNode nodePep in nodePepGroup.Children)
{
var nodePepAdd = nodePep;
int charge;
if (_charges.TryGetValue(nodePep.Id.GlobalIndex, out charge))
{
var settingsCharge = _settings.ChangeTransitionFilter(f => f.ChangePrecursorCharges(new[] {charge}));
nodePepAdd = (PeptideDocNode) nodePep.ChangeSettings(settingsCharge, diff)
.ChangeAutoManageChildren(false);
}
newChildren.Add(nodePepAdd);
}
return (PeptideGroupDocNode) nodePepGroup.ChangeChildren(newChildren);
}
