void dataGridView1_CurrentCellChanged(object sender, EventArgs e)
{
if (dataGridView1.CurrentCell == null || dataGridView1.CurrentRow == null)
{
return;
}
var rowTag = (Tuple <IdentityPath, PeptideDocNode>)dataGridView1.CurrentRow.Tag;
if (rowTag == null)
{
return;
}
PeptideDocNode peptideDocNode = rowTag.Item2;
// Expecting to find this peptide
var peptideGroupDocNode = PeptideGroupDocNodes.FirstOrDefault(g => null != g.FindNode(peptideDocNode.Peptide));
if (peptideGroupDocNode == null)
{
return;
}
String peptideSequence = peptideDocNode.Peptide.Target.Sequence;
String proteinSequence;
var proteinColumn = dataGridView1.Columns[dataGridView1.CurrentCell.ColumnIndex].Tag as ProteinColumn;
ProteinMetadata metadata;
if (proteinColumn == null)
{
metadata = peptideGroupDocNode.ProteinMetadata;
proteinSequence = peptideGroupDocNode.PeptideGroup.Sequence;
}
else
{
metadata = proteinColumn.Protein.ProteinMetadata;
proteinSequence = proteinColumn.Protein.Sequence;
}
tbxProteinName.Text = metadata.Name;
tbxProteinDescription.Text = metadata.Description;
tbxProteinDetails.Text = metadata.DisplayTextWithoutNameOrDescription(); // Don't show name or description
if (!string.IsNullOrEmpty(proteinSequence))
{
var regex = new Regex(peptideSequence);
// ReSharper disable LocalizableElement
StringBuilder formattedText = new StringBuilder("{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}{\\colortbl ;\\red0\\green0\\blue255;}\\f0\\pard \\fs16");
// ReSharper restore LocalizableElement
int lastIndex = 0;
for (Match match = regex.Match(proteinSequence, 0); match.Success; lastIndex = match.Index + match.Length, match = match.NextMatch())
{
// ReSharper disable LocalizableElement
formattedText.Append("\\cf0\\b0 " + proteinSequence.Substring(lastIndex, match.Index - lastIndex));
formattedText.Append("\\cf1\\b " + proteinSequence.Substring(match.Index, match.Length));
// ReSharper restore LocalizableElement
}
// ReSharper disable LocalizableElement
formattedText.Append("\\cf0\\b0 " + proteinSequence.Substring(lastIndex, proteinSequence.Length - lastIndex));
formattedText.Append("\\par }");
// ReSharper restore LocalizableElement
richTextBoxSequence.Rtf = formattedText.ToString();
}
}
private PeptideDocNode RemoveTransition(PeptideDocNode nodePep)
{
var precursors = nodePep.TransitionGroups.ToList();
precursors[0] = (TransitionGroupDocNode)precursors[0].ChangeChildren(precursors[0].Children.Skip(1).ToList());
return((PeptideDocNode)nodePep.ChangeChildren(precursors.Cast <DocNode>().ToList()));
}
private static IEnumerable <KeyValuePair <IsotopeLabelType, string> > GetTypedModifiedSequences(
PeptideDocNode nodePep, SrmSettings settings)
{
foreach (var labelType in settings.PeptideSettings.Modifications.GetModificationTypes())
{
if (nodePep.Peptide.IsCustomMolecule)
{
continue;
}
// Only return the modified sequence, if the peptide actually as a child
// of this type.
if (!nodePep.HasChildType(labelType))
{
continue;
}
var calc = settings.TryGetPrecursorCalc(labelType, nodePep.ExplicitMods);
if (calc == null)
{
continue;
}
string modSequence = calc.GetModifiedSequence(nodePep.Peptide.Target, true).Sequence; // Never have to worry about this being a custom molecule, we already checked
// Only return if the modified sequence contains modifications
if (modSequence.Contains('['))
{
yield return(new KeyValuePair <IsotopeLabelType, string>(labelType, modSequence));
}
}
}
public PickTransitionGroupTip(PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup, SrmSettings settings)
{
_nodePep = nodePep;
_nodeGroup = nodeGroup;
_settings = settings;
}
public static string GetTitle(PeptideDocNode peptideDocNode, TransitionGroupDocNode transitionGroupDocNode, IsotopeLabelType labelType)
{
string libraryNamePrefix = string.Empty;
//if (!string.IsNullOrEmpty(libraryNamePrefix))
// libraryNamePrefix += @" - ";
TransitionGroup transitionGroup = transitionGroupDocNode.TransitionGroup;
string sequence;
if (transitionGroup.Peptide.IsCustomMolecule)
{
sequence = transitionGroupDocNode.CustomMolecule.DisplayName;
}
else if (peptideDocNode?.ExplicitMods != null && peptideDocNode.ExplicitMods.Crosslinks.Count != 0)
{
sequence = peptideDocNode.GetCrosslinkedSequence();
}
else
{
sequence = transitionGroup.Peptide.Target.Sequence;
}
var charge = transitionGroup.PrecursorAdduct.ToString(); // Something like "2" or "-3" for protonation, or "[M+Na]" for small molecules
if (transitionGroup.Peptide.IsCustomMolecule)
{
return(labelType.IsLight
? string.Format(@"{0}{1}{2}", libraryNamePrefix, transitionGroup.Peptide.CustomMolecule.DisplayName, charge)
: string.Format(@"{0}{1}{2} ({3})", libraryNamePrefix, sequence, charge, labelType));
}
return(labelType.IsLight
? string.Format(Resources.SpectrumGraphItem_Title__0__1__Charge__2__, libraryNamePrefix, sequence, charge)
: string.Format(Resources.SpectrumGraphItem_Title__0__1__Charge__2__3__, libraryNamePrefix, sequence, charge, labelType));
}
private static int GetChargeCount(PeptideDocNode nodePep)
{
return(nodePep.TransitionGroups
.Select(groupNode => groupNode.TransitionGroup.PrecursorAdduct)
.Distinct()
.Count());
}
public PeptideMatch(PeptideDocNode nodePep, IEnumerable <ProteinInfo> proteins, SpectrumHeaderInfo libInfo, bool matchesFilterSettings) : this()
{
NodePep = nodePep;
Proteins = proteins == null ? null : proteins.ToList();
MatchesFilterSettings = matchesFilterSettings;
LibInfo = libInfo;
}
protected override bool IsMatch(string seq, PeptideDocNode nodePep, out TransitionGroupDocNode nodeGroup)
{
string seqSimplified = SimplifyUnimodSequence(seq);
var seqLight = FastaSequence.StripModifications(seqSimplified, FastaSequence.RGX_HEAVY);
var seqHeavy = FastaSequence.StripModifications(seqSimplified, FastaSequence.RGX_LIGHT);
var calcLight = Settings.TryGetPrecursorCalc(IsotopeLabelType.light, nodePep.ExplicitMods);
foreach (TransitionGroupDocNode nodeGroupChild in nodePep.Children)
{
nodeGroup = nodeGroupChild;
if (nodeGroup.TransitionGroup.LabelType.IsLight)
{
// Light modifications must match.
if (!EqualsModifications(seqLight, calcLight, null))
{
return(false);
}
// If the sequence only has light modifications, a match has been found.
if (Equals(seqLight, seqSimplified))
{
return(true);
}
}
else
{
var calc = Settings.TryGetPrecursorCalc(nodeGroup.TransitionGroup.LabelType, nodePep.ExplicitMods);
if (calc != null && EqualsModifications(seqHeavy, calc, calcLight))
{
return(true);
}
}
}
nodeGroup = null;
return(false);
}
public static int GetPeakImageIndex(TransitionDocNode nodeTran,
PeptideDocNode nodePep, SequenceTree sequenceTree)
{
var settings = sequenceTree.Document.Settings;
if (!settings.HasResults)
{
return(-1);
}
int index = sequenceTree.GetDisplayResultsIndex(nodePep);
float?ratio = (nodeTran.HasResults ? nodeTran.GetPeakCountRatio(index, settings.TransitionSettings.Integration.IsIntegrateAll) : null);
if (ratio == null)
{
return((int)SequenceTree.StateImageId.peak_blank);
}
if (ratio == 0)
{
return((int)SequenceTree.StateImageId.no_peak);
}
if (ratio < 1.0)
{
return((int)SequenceTree.StateImageId.keep);
}
return((int)SequenceTree.StateImageId.peak);
}
public List <int> PotentiallyModifiedResidues(PeptideDocNode peptideDocNode, StaticMod mod)
{
List <int> indexes = new List <int>();
var sequence = peptideDocNode.Peptide.Sequence;
for (int index = 0; index < sequence.Length; index++)
{
if (mod.Terminus == ModTerminus.N && index != 0)
{
continue;
}
if (mod.Terminus == ModTerminus.C && index != sequence.Length - 1)
{
continue;
}
if (mod.AAs != null)
{
var aa = sequence[index];
if (mod.AAs.IndexOf(aa) < 0)
{
continue;
}
}
indexes.Add(index);
}
return(indexes);
}
// ReSharper disable SuggestBaseTypeForParameter
private void CalcStats(PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup)
// ReSharper restore SuggestBaseTypeForParameter
{
var times = new List <double>();
foreach (TransitionGroupDocNode nodePepChild in nodePep.Children)
{
double?meanArea, meanTime, meanMassError;
CalcStats(nodePepChild, out meanArea, out meanTime, out meanMassError);
if (!Equals(nodeGroup.TransitionGroup.PrecursorAdduct, nodePepChild.TransitionGroup.PrecursorAdduct))
{
continue;
}
if (meanTime.HasValue)
{
times.Add(meanTime.Value);
}
if (ReferenceEquals(nodeGroup, nodePepChild))
{
AreaGroup = meanArea ?? 0;
TimeGroup = meanTime ?? 0;
MassErrorGroup = meanMassError ?? 0;
}
}
// AreaPepCharge = (areas.Count > 0 ? new Statistics(areas).Mean() : 0);
TimePepCharge = (times.Count > 0 ? new Statistics(times).Mean() : 0);
}
public static void DrawPeptideText(PeptideDocNode nodePep,
SrmSettings settings,
IEnumerable <TextSequence> textSequences,
Graphics g,
Rectangle bounds,
ModFontHolder fonts,
Color foreColor,
Color backColor)
{
if (textSequences == null)
{
textSequences = CreateTextSequences(nodePep, settings, GetLabel(nodePep, string.Empty), g, fonts);
}
Rectangle rectDraw = new Rectangle(0, bounds.Y, 0, bounds.Height);
foreach (var textSequence in textSequences)
{
rectDraw.X = textSequence.Position + bounds.X + TreeViewMS.PADDING;
rectDraw.Width = textSequence.Width;
// Use selection highlight color, if the background is highlight.
if (backColor != SystemColors.Highlight)
{
foreColor = textSequence.Color;
}
TextRenderer.DrawText(g, textSequence.Text, textSequence.Font, rectDraw,
foreColor, backColor, FORMAT_TEXT_SEQUENCE);
}
}
public PeptideAnnotationPair(PeptideDocNode peptide, TransitionGroupDocNode tranGroup, string annotation, double cvRaw)
{
Peptide = peptide;
TransitionGroup = tranGroup;
Annotation = annotation;
CVRaw = cvRaw;
}
public virtual void AddToInternalData(ICollection <InternalData> data, List <AreaInfo> areas,
PeptideGroupDocNode peptideGroup, PeptideDocNode peptide, TransitionGroupDocNode tranGroup, object annotation)
{
var normalizedStatistics = new Statistics(areas.Select(a => a.NormalizedArea));
var normalizedMean = normalizedStatistics.Mean();
var normalizedStdDev = normalizedStatistics.StdDev();
// If the mean is 0 or NaN or the standard deviaiton is NaN the cv would also be NaN
if (normalizedMean == 0.0 || double.IsNaN(normalizedMean) || double.IsNaN(normalizedStdDev))
{
return;
}
// Round cvs so that the smallest difference between two cv's is BinWidth
var cv = normalizedStdDev / normalizedMean;
data.Add(new InternalData
{
Peptide = peptide,
PeptideGroup = peptideGroup,
TransitionGroup = tranGroup,
Annotation = annotation,
CV = cv,
CVBucketed = cv,
Area = 0.0
});
}
public SummaryPeptidePeakData(SrmDocument document,
PeptideDocNode nodePep,
IList <TransitionGroupDocNode> nodeGroups,
ChromatogramSet chromatogramSet,
ChromatogramGroupInfo chromGroupInfoPrimary)
{
_peakIndex = -1;
_chromGroupInfoPrimary = chromGroupInfoPrimary;
NodePep = nodePep;
FileInfo = chromatogramSet.GetFileInfo(chromGroupInfoPrimary);
TransitionGroupPeakData = new SummaryTransitionGroupPeakData[nodeGroups.Count];
for (int i = 0; i < nodeGroups.Count; i++)
{
TransitionGroupPeakData[i] = new SummaryTransitionGroupPeakData(document,
nodePep, nodeGroups[i], chromatogramSet, chromGroupInfoPrimary);
}
// Avoid extra ToArray() calls, since they show up in a profiler for big files
bool?standard;
if (AllSameStandardType(TransitionGroupPeakData, out standard))
{
AnalyteGroupPeakData = standard.HasValue && !standard.Value ? TransitionGroupPeakData : EMPTY_DATA;
StandardGroupPeakData = standard.HasValue && standard.Value ? TransitionGroupPeakData : EMPTY_DATA;
}
else
{
AnalyteGroupPeakData = TransitionGroupPeakData.Where(t => !t.IsStandard).ToArray();
StandardGroupPeakData = TransitionGroupPeakData.Where(t => t.IsStandard).ToArray();
}
}
private static IEnumerable <TransitionDocNode> FindCandidateTransitions(PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup, TransitionDocNode nodeTran)
{
var candidateGroups = FindCandidateGroups(nodePep, nodeGroup);
if (candidateGroups.Length < 2)
{
return new[] { nodeTran }
}
;
Debug.Assert(ReferenceEquals(nodeGroup, candidateGroups[0]));
var listCandidates = new List <TransitionDocNode> {
nodeTran
};
var transition = nodeTran.Transition;
for (int i = 1; i < candidateGroups.Length; i++)
{
foreach (TransitionDocNode nodeTranCandidate in candidateGroups[i].Children)
{
var transitionCandidate = nodeTranCandidate.Transition;
if (transition.Charge == transitionCandidate.Charge && // CONSIDER(bspratt) is this about charge per se, or about adduct?
transition.Ordinal == transitionCandidate.Ordinal &&
transition.IonType == transitionCandidate.IonType)
{
listCandidates.Add(nodeTranCandidate);
break;
}
}
}
return(listCandidates.ToArray());
}
public PeptideQuantifier(PeptideGroupDocNode peptideGroup, PeptideDocNode peptideDocNode,
QuantificationSettings quantificationSettings)
{
PeptideGroupDocNode = peptideGroup;
PeptideDocNode = peptideDocNode;
QuantificationSettings = quantificationSettings;
}
public void WriteTransition(AbstractMassListExporter exporter,
PeptideGroupDocNode seq,
PeptideDocNode peptide,
TransitionGroupDocNode group,
TransitionGroupDocNode groupPrimary,
TransitionDocNode transition,
int step)
{
if (!HasFile)
{
throw new IOException(Resources.FileIterator_WriteTransition_Unexpected_failure_writing_transitions);
}
exporter.WriteTransition(_writer, FileCount, seq, peptide, group, groupPrimary, transition, step);
// If not full-scan, count transtions
if (!_isPrecursorLimited)
{
TransitionCount++;
}
// Otherwise, count precursors
else if (!ReferenceEquals(_nodeGroupLast, group))
{
TransitionCount++;
_nodeGroupLast = group;
}
}
private bool PointFromPeptide(PeptideDocNode nodePeptide, out double score, out double time)
{
if (nodePeptide != null && _regressionAll != null)
{
int iRefined = 0, iOut = 0;
for (int i = 0; i < _peptidesIndexes.Count; i++)
{
if (_outlierIndexes != null && _outlierIndexes.Contains(i))
{
if (ReferenceEquals(nodePeptide, _peptidesIndexes[i].DocNode))
{
score = _scoresOutliers[iOut];
time = _timesOutliers[iOut];
return(true);
}
iOut++;
}
else
{
if (ReferenceEquals(nodePeptide, _peptidesIndexes[i].DocNode))
{
score = _scoresRefined[iRefined];
time = _timesRefined[iRefined];
return(true);
}
iRefined++;
}
}
}
score = 0;
time = 0;
return(false);
}
public PeptidePrecursorNCE(PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup, IsotopeLabelType labelType, int?nce)
{
NodePep = nodePep;
NodeGroup = nodeGroup;
LabelType = labelType;
NCE = nce;
}
public void Add(IdentityPath pathPep, PeptideDocNode nodePep)
{
foreach (var nodeGroups in nodePep.TransitionGroups)
{
Add(pathPep, nodePep, nodeGroups);
}
}
public PeptideQuantifier(PeptideGroupDocNode peptideGroup, PeptideDocNode peptideDocNode,
QuantificationSettings quantificationSettings)
{
PeptideGroupDocNode = peptideGroup;
PeptideDocNode = peptideDocNode;
QuantificationSettings = quantificationSettings;
}
private static int GetPeakImageIndex(TransitionGroupDocNode nodeGroup,
PeptideDocNode nodeParent, SequenceTree sequenceTree)
{
var settings = sequenceTree.Document.Settings;
if (!settings.HasResults)
{
return(-1);
}
int index = sequenceTree.GetDisplayResultsIndex(nodeParent);
float?ratio = (nodeGroup.HasResults ? nodeGroup.GetPeakCountRatio(index) : null);
if (ratio == null)
{
return((int)SequenceTree.StateImageId.peak_blank);
}
if (ratio < 0.5)
{
return((int)SequenceTree.StateImageId.no_peak);
}
if (ratio < 1.0)
{
return((int)SequenceTree.StateImageId.keep);
}
return((int)SequenceTree.StateImageId.peak);
}
private Dictionary <PeptideDocNode.TransitionKey, TransitionChromInfo> GetTransitionsToNormalizeAgainst(
PeptideDocNode peptideDocNode, int replicateIndex)
{
if (string.IsNullOrEmpty(NormalizationMethod.IsotopeLabelTypeName))
{
return(null);
}
var result = new Dictionary <PeptideDocNode.TransitionKey, TransitionChromInfo>();
foreach (var transitionGroup in peptideDocNode.TransitionGroups)
{
if (!Equals(NormalizationMethod.IsotopeLabelTypeName, transitionGroup.TransitionGroup.LabelType.Name))
{
continue;
}
foreach (var transition in transitionGroup.Transitions)
{
if (null == transition.Results || transition.Results.Count <= replicateIndex)
{
continue;
}
var chromInfoList = transition.Results[replicateIndex];
if (null == chromInfoList)
{
continue;
}
var chromInfo = chromInfoList.FirstOrDefault(chrom => 0 == chrom.OptimizationStep);
if (null != chromInfo && !chromInfo.IsEmpty)
{
result[GetRatioTransitionKey(transitionGroup, transition)] = chromInfo;
}
}
}
return(result);
}
public static Image GetPeakImage(TransitionGroupDocNode nodeGroup,
PeptideDocNode nodeParent, SequenceTree sequenceTree)
{
int imageIndex = GetPeakImageIndex(nodeGroup, nodeParent, sequenceTree);
return(imageIndex != -1 ? sequenceTree.StateImageList.Images[imageIndex] : null);
}
protected PointPairList GetPeptidePointPairList(PeptideGroupDocNode peptideGroup,
PeptideDocNode peptideDocNode, Func <PeptideChromInfoData, bool> isMissing, Func <int, ICollection <PeptideChromInfoData>, PointPair> createPeptidePointPairFunc)
{
var peptideChromInfoDatas =
PeptideChromInfoData.GetPeptideChromInfoDatas(_document.Settings.MeasuredResults, peptideDocNode);
return(MakePointPairLists(DisplayTypeChrom.all, peptideChromInfoDatas, isMissing, createPeptidePointPairFunc).First());
}
private static double GetCollisionEnergy(SrmSettings settings, PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup, CollisionEnergyRegression regression, int step)
{
var charge = nodeGroup.TransitionGroup.PrecursorAdduct;
double mz = settings.GetRegressionMz(nodePep, nodeGroup);
return(regression.GetCollisionEnergy(charge, mz) + regression.StepSize * step);
}
public static string GetTitle(PeptideDocNode nodePep)
{
if (nodePep == null)
{
return(string.Empty);
}
return(nodePep.ModifiedSequenceDisplay);
}
public GraphPointData(PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup, IdentityPath identityPath)
{
NodePep = nodePep;
NodeGroup = nodeGroup;
IdentityPath = identityPath;
CalcStats(nodePep, nodeGroup);
}
public PeptideQuantifier(Func <NormalizationData> getNormalizationDataFunc, PeptideGroupDocNode peptideGroup, PeptideDocNode peptideDocNode,
QuantificationSettings quantificationSettings)
{
PeptideGroupDocNode = peptideGroup;
PeptideDocNode = peptideDocNode;
QuantificationSettings = quantificationSettings;
_getNormalizationDataFunc = getNormalizationDataFunc;
}
public SummaryTransitionGroupPeakData(SrmDocument document,
PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup,
ChromatogramSet chromatogramSet,
ChromatogramGroupInfo chromGroupInfoPrimary)
{
_peakIndex = -1;
NodeGroup = nodeGroup;
IsStandard = document.Settings.PeptideSettings.Modifications.InternalStandardTypes
.Contains(nodeGroup.TransitionGroup.LabelType);
TransitionPeakData = Ms1TranstionPeakData = Ms2TranstionPeakData = EMPTY_DATA;
ChromatogramGroupInfo[] arrayChromInfo;
var measuredResults = document.Settings.MeasuredResults;
float mzMatchTolerance = (float)document.Settings.TransitionSettings.Instrument.MzMatchTolerance;
if (measuredResults.TryLoadChromatogram(chromatogramSet, nodePep, nodeGroup, mzMatchTolerance, false,
out arrayChromInfo))
{
_chromGroupInfo = arrayChromInfo.FirstOrDefault(ci =>
Equals(ci.FilePath, chromGroupInfoPrimary.FilePath));
if (_chromGroupInfo != null)
{
int ms1Count = 0, ms2Count = 0, totalCount = 0;
// Assume there will be one per transtion
var listPeakData = new ITransitionPeakData <ISummaryPeakData> [nodeGroup.TransitionCount];
foreach (var nodeTran in nodeGroup.Transitions)
{
var tranInfo = _chromGroupInfo.GetTransitionInfo(nodeTran, mzMatchTolerance, chromatogramSet.OptimizationFunction);
if (tranInfo == null)
{
continue;
}
listPeakData[totalCount++] = new SummaryTransitionPeakData(document, nodeTran, chromatogramSet, tranInfo);
if (nodeTran.IsMs1)
{
ms1Count++;
}
else
{
ms2Count++;
}
}
// If something was missing reallocate, which can't be slower than List.ToArray()
if (totalCount < listPeakData.Length)
{
var peakDatasShort = new ITransitionPeakData <ISummaryPeakData> [totalCount];
Array.Copy(listPeakData, peakDatasShort, totalCount);
listPeakData = peakDatasShort;
}
TransitionPeakData = listPeakData.ToArray();
Ms1TranstionPeakData = GetTransitionTypePeakData(ms1Count, ms2Count, true);
Ms2TranstionPeakData = GetTransitionTypePeakData(ms1Count, ms2Count, false);
}
}
}
public GroupComparisonSelector(PeptideGroupDocNode protein, PeptideDocNode peptide, IsotopeLabelType labelType,
int? msLevel, GroupIdentifier groupIdentifier)
{
Protein = protein;
Peptide = peptide;
LabelType = labelType;
MsLevel = msLevel;
GroupIdentifier = groupIdentifier;
}
public static PeptideQuantifier GetPeptideQuantifier(SrmSettings srmSettings, PeptideGroupDocNode peptideGroup, PeptideDocNode peptide)
{
var mods = srmSettings.PeptideSettings.Modifications;
// Quantify on all label types which are not internal standards.
ICollection<IsotopeLabelType> labelTypes = ImmutableList.ValueOf(mods.GetModificationTypes()
.Except(mods.InternalStandardTypes));
return new PeptideQuantifier(peptideGroup, peptide, srmSettings.PeptideSettings.Quantification)
{
MeasuredLabelTypes = labelTypes
};
}
protected override void WriteTransition(TextWriter writer,
XmlFastaSequence sequence,
XmlPeptide peptide,
XmlTransition transition)
{
char separator = TextUtil.GetCsvSeparator(_cultureInfo);
writer.Write(transition.PrecursorMz.ToString(_cultureInfo));
writer.Write(separator);
writer.Write(transition.ProductMz.ToString(_cultureInfo));
writer.Write(separator);
if (MethodType == ExportMethodType.Standard)
writer.Write(Math.Round(DwellTime, 2).ToString(_cultureInfo));
else
{
if (!peptide.PredictedRetentionTime.HasValue)
throw new InvalidOperationException(Resources.XmlThermoMassListExporter_WriteTransition_Attempt_to_write_scheduling_parameters_failed);
writer.Write(peptide.PredictedRetentionTime.Value.ToString(_cultureInfo));
}
writer.Write(separator);
// Write special ID for ABI software
var fastaSequence = new FastaSequence(sequence.Name, sequence.Description, null, peptide.Sequence);
var newPeptide = new Peptide(fastaSequence, peptide.Sequence, 0, peptide.Sequence.Length, peptide.MissedCleavages);
var nodePep = new PeptideDocNode(newPeptide);
string modifiedPepSequence = AbiMassListExporter.GetSequenceWithModsString(nodePep, _document.Settings); // Not L10N;
string extPeptideId = string.Format("{0}.{1}.{2}.{3}", // Not L10N
sequence.Name,
modifiedPepSequence,
GetTransitionName(transition),
"light"); // Not L10N : file format
writer.WriteDsvField(extPeptideId, separator);
writer.Write(separator);
writer.Write(Math.Round(transition.DeclusteringPotential ?? 0, 1).ToString(_cultureInfo));
writer.Write(separator);
writer.Write(Math.Round(transition.CollisionEnergy, 1).ToString(_cultureInfo));
writer.WriteLine();
}
protected override bool IsMatch(PeptideDocNode nodePep)
{
// Populate look-ups for later to be able to determine if transitions
// are fully matched or not.
_dictChargeToMatchInfo = new Dictionary<int, TransitionMatchInfo>();
foreach (var nodeGroup in nodePep.TransitionGroups)
{
TransitionMatchInfo matchInfo;
int charge = nodeGroup.TransitionGroup.PrecursorCharge;
if (!_dictChargeToMatchInfo.TryGetValue(charge, out matchInfo))
{
matchInfo = new TransitionMatchInfo();
_dictChargeToMatchInfo.Add(charge, matchInfo);
}
matchInfo.AddTransitionGroup(nodeGroup);
foreach (var nodeTran in nodeGroup.Transitions)
{
matchInfo.AddTransition(nodeTran, nodeGroup);
}
}
// Not actually looking for peptides
return false;
}
protected override bool IsMatch(PeptideDocNode nodePep)
{
return nodePep != null && nodePep.HasResults && nodePep.Results.All(chromInfo => chromInfo == null);
}
public double GetRegressionMz(PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup)
{
double mz = nodeGroup.PrecursorMz;
// Always use the light m/z value to ensure regression values are consistent between light and heavy
if (!nodeGroup.TransitionGroup.LabelType.IsLight)
{
if (nodePep.Peptide.IsCustomIon)
{
double mass = nodeGroup.TransitionGroup.CustomIon.GetMass(TransitionSettings.Prediction.PrecursorMassType);
mz = BioMassCalc.CalculateIonMz(mass, nodeGroup.TransitionGroup.PrecursorCharge);
}
else
{
double massH = GetPrecursorMass(IsotopeLabelType.light,
nodePep.Peptide.Sequence, nodePep.ExplicitMods);
mz = SequenceMassCalc.GetMZ(massH, nodeGroup.TransitionGroup.PrecursorCharge);
}
}
return mz;
}
public string GetModifiedSequence(PeptideDocNode nodePep)
{
Assume.IsFalse(nodePep.Peptide.IsCustomIon);
Assume.IsNotNull(nodePep.ModifiedSequence);
return nodePep.ModifiedSequence;
}
public string GetDisplayName(PeptideDocNode nodePep)
{
return nodePep.Peptide.IsCustomIon ? nodePep.CustomIon.DisplayName : nodePep.ModifiedSequenceDisplay;
}
public double[] GetBestRetentionTimes(PeptideDocNode nodePep, MsDataFileUri filePath)
{
if (!nodePep.IsProteomic)
return new double[0]; // No retention time prediction for small molecules
string lookupSequence = nodePep.SourceUnmodifiedTextId;
var lookupMods = nodePep.SourceExplicitMods;
if (filePath != null)
{
var times = GetRetentionTimes(filePath, lookupSequence, lookupMods);
if (times.Length > 0)
return times;
times = GetAllRetentionTimes(filePath, lookupSequence, lookupMods);
if (times.Length > 0)
return times;
}
return GetUnalignedRetentionTimes(lookupSequence, lookupMods);
}
public void ProcessMolecule(PeptideDocNode nodePep)
{
int? percentComplete = ProgressStatus.ThreadsafeIncementPercent(ref _seenMoleculeCount, MoleculeCount);
UpdateProgress(percentComplete, false);
}
public string GetSourceTextId(PeptideDocNode nodePep)
{
Assume.IsNotNull(nodePep.SourceTextId);
return nodePep.SourceTextId;
}
public double? PredictRetentionTime(SrmDocument document,
PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup,
int? replicateNum,
ExportSchedulingAlgorithm algorithm,
bool singleWindow,
out double windowRT)
{
return PredictRetentionTimeUsingSpecifiedReplicates(document, nodePep, nodeGroup, replicateNum, algorithm,
singleWindow, null, out windowRT);
}
/// <summary>
/// Get drift time for the charged peptide from explicitly set values, or our drift time predictor, or,
/// failing that, from the provided spectral library if it has bare drift times.
/// If no drift info is available, returns a new zero'd out drift time info object.
/// </summary>
public DriftTimeInfo GetDriftTime(PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup,
LibraryIonMobilityInfo libraryIonMobilityInfo, out double windowDtMsec)
{
if (nodeGroup.ExplicitValues.DriftTimeMsec.HasValue)
{
// Use the explicitly specified value
var result = new DriftTimeInfo(nodeGroup.ExplicitValues.DriftTimeMsec,
nodeGroup.ExplicitValues.DriftTimeHighEnergyOffsetMsec ?? 0);
// Now get the resolving power
if (DriftTimePredictor != null)
{
windowDtMsec = DriftTimePredictor.InverseResolvingPowerTimesTwo*result.DriftTimeMsec(false).Value;
}
else if (LibraryDriftTimesResolvingPower.HasValue)
{
windowDtMsec = 2.0 * result.DriftTimeMsec(false).Value / LibraryDriftTimesResolvingPower.Value;
}
else
{
windowDtMsec = 0;
}
return result;
}
else
{
return GetDriftTimeHelper(
new LibKey(nodePep.RawTextId, nodeGroup.TransitionGroup.PrecursorCharge), libraryIonMobilityInfo,
out windowDtMsec);
}
}
private bool IsMatch(ChromInfo chromInfo, PeptideDocNode nodePep)
{
var key = new KeyValuePair<int, int>(nodePep.Id.GlobalIndex, chromInfo.FileId.GlobalIndex);
if (!_featureDictionary.ContainsKey(key))
return false;
var listFeatures = _featureDictionary[key];
foreach (var features in listFeatures)
{
if (IsUnknownScore(features, _selectedCalculator))
return true;
}
return false;
}
/// <summary>
/// Create a new set of explicit modifications on a peptide from a list of desired
/// modifications of each type, and the global lists of available modifications.
/// </summary>
/// <param name="nodePep">The peptide to modify</param>
/// <param name="staticMods">Static modifications to be applied</param>
/// <param name="listStaticMods">Global static modifications</param>
/// <param name="heavyMods">All sets of isotope labeled mods to be applied</param>
/// <param name="listHeavyMods">Global isotope labeled mods</param>
/// <param name="implicitOnly">True to create an explicit expression of the implicit modifications</param>
public ExplicitMods(PeptideDocNode nodePep,
IList<StaticMod> staticMods, MappedList<string, StaticMod> listStaticMods,
IEnumerable<TypedModifications> heavyMods, MappedList<string, StaticMod> listHeavyMods,
bool implicitOnly = false)
{
Peptide = nodePep.Peptide;
var modifications = new List<TypedExplicitModifications>();
TypedExplicitModifications staticTypedMods = null;
// Add static mods, if applicable
if (staticMods != null)
{
IList<ExplicitMod> explicitMods = GetImplicitMods(staticMods, listStaticMods);
// If the peptide has variable modifications, make them all override
// the modification state of the default implicit mods
if (!implicitOnly && nodePep.HasVariableMods)
{
explicitMods = MergeExplicitMods(nodePep.ExplicitMods.StaticModifications,
explicitMods, staticMods);
}
staticTypedMods = new TypedExplicitModifications(Peptide,
IsotopeLabelType.light, explicitMods);
modifications.Add(staticTypedMods);
}
foreach (TypedModifications typedMods in heavyMods)
{
var explicitMods = GetImplicitMods(typedMods.Modifications, listHeavyMods);
var typedHeavyMods = new TypedExplicitModifications(Peptide,
typedMods.LabelType, explicitMods);
modifications.Add(typedHeavyMods.AddModMasses(staticTypedMods));
}
_modifications = MakeReadOnly(modifications.ToArray());
}
private Dictionary<PeptideDocNode.TransitionKey, TransitionChromInfo> GetTransitionsToNormalizeAgainst(
PeptideDocNode peptideDocNode, int replicateIndex)
{
if (string.IsNullOrEmpty(NormalizationMethod.IsotopeLabelTypeName))
{
return null;
}
var result = new Dictionary<PeptideDocNode.TransitionKey, TransitionChromInfo>();
foreach (var transitionGroup in peptideDocNode.TransitionGroups)
{
if (!Equals(NormalizationMethod.IsotopeLabelTypeName, transitionGroup.TransitionGroup.LabelType.Name))
{
continue;
}
foreach (var transition in transitionGroup.Transitions)
{
if (null == transition.Results || transition.Results.Count <= replicateIndex)
{
continue;
}
var chromInfoList = transition.Results[replicateIndex];
if (null == chromInfoList)
{
continue;
}
var chromInfo = chromInfoList.FirstOrDefault(chrom => 0 == chrom.OptimizationStep);
if (null != chromInfo && !chromInfo.IsEmpty)
{
result[GetRatioTransitionKey(transitionGroup, transition)] = chromInfo;
}
}
}
return result;
}
protected virtual bool IsMatch(PeptideDocNode nodePep)
{
return false;
}
private bool IsMatch(PeptideDocNode nodePep)
{
// The peptide node matches if its results are missing for all files
return nodePep.HasResults &&
nodePep.Results.All(chromInfoList => chromInfoList == null || chromInfoList.All(chromInfo => IsMatch(chromInfo, nodePep)));
}
/// <summary>
/// Used to help make sure that all precursors with matching retention time for
/// a peptide get the same scheduling time when using measured results, which
/// may have had different retention time boundaries set by the user.
/// </summary>
private static IEnumerable<TransitionGroupDocNode> GetSchedulingGroups(PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup)
{
if (nodeGroup.RelativeRT != RelativeRT.Matching)
return new[] {nodeGroup};
return
nodePep.Children.Cast<TransitionGroupDocNode>().Where(
nodeGroupChild => nodeGroupChild.RelativeRT == RelativeRT.Matching);
}
private GroupComparisonResults ComputeComparisonResults(GroupComparer groupComparer, SrmDocument document,
CancellationToken cancellationToken)
{
DateTime startTime = DateTime.Now;
List<GroupComparisonResult> results = new List<GroupComparisonResult>();
if (groupComparer.IsValid)
{
var peptideGroups = document.PeptideGroups.ToArray();
for (int i = 0; i < peptideGroups.Length; i++)
{
int percentComplete = 100 * i / peptideGroups.Length;
lock (_lock)
{
cancellationToken.ThrowIfCancellationRequested();
_percentComplete = percentComplete;
}
var peptideGroup = peptideGroups[i];
IEnumerable<PeptideDocNode> peptides;
if (groupComparer.ComparisonDef.PerProtein)
{
peptides = new PeptideDocNode[] {null};
}
else
{
peptides = peptideGroup.Peptides;
}
foreach (var peptide in peptides)
{
results.AddRange(groupComparer.CalculateFoldChanges(peptideGroup, peptide));
}
}
}
DateTime endTime = DateTime.Now;
return new GroupComparisonResults(groupComparer, results, startTime, endTime);
}
public double? PredictRetentionTimeForChromImport(SrmDocument document, PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup, out double windowRt)
{
return PredictRetentionTimeUsingSpecifiedReplicates(document, nodePep, nodeGroup, null,
ExportSchedulingAlgorithm.Average, false, chromatogramSet => chromatogramSet.UseForRetentionTimeFilter, out windowRt);
}
public static CalibrationCurveFitter GetCalibrationCurveFitter(SrmSettings srmSettings,
PeptideGroupDocNode peptideGroup, PeptideDocNode peptide)
{
return new CalibrationCurveFitter(PeptideQuantifier.GetPeptideQuantifier(srmSettings, peptideGroup, peptide), srmSettings);
}
private double? PredictRetentionTimeUsingSpecifiedReplicates(SrmDocument document,
PeptideDocNode nodePep,
TransitionGroupDocNode nodeGroup,
int? replicateNum,
ExportSchedulingAlgorithm algorithm,
bool singleWindow,
Predicate<ChromatogramSet> replicateFilter,
out double windowRT)
{
// If peptide has an explicitly set RT, use that
if (nodePep.ExplicitRetentionTime != null &&
(MeasuredRTWindow.HasValue || nodePep.ExplicitRetentionTime.RetentionTimeWindow.HasValue))
{
// If peptide has an explicitly set RT window, use that, or the global setting
windowRT = nodePep.ExplicitRetentionTime.RetentionTimeWindow ?? MeasuredRTWindow.Value;
return nodePep.ExplicitRetentionTime.RetentionTime;
}
// Safe defaults
double? predictedRT = null;
windowRT = 0;
// Use measurements, if set and available
bool useMeasured = (UseMeasuredRTs && MeasuredRTWindow.HasValue && document.Settings.HasResults);
if (useMeasured)
{
var schedulingGroups = GetSchedulingGroups(nodePep, nodeGroup);
var peakTime = TransitionGroupDocNode.GetSchedulingPeakTimes(schedulingGroups, document, algorithm, replicateNum, replicateFilter);
if (peakTime != null)
predictedRT = peakTime.CenterTime;
if (predictedRT.HasValue)
windowRT = MeasuredRTWindow.Value;
else if (nodePep.Children.Count > 1)
{
// If their are other children of this peptide, look for one
// with results that can be used to predict the retention time.
foreach (TransitionGroupDocNode nodeGroupOther in nodePep.Children)
{
if (!ReferenceEquals(nodeGroup, nodeGroupOther))
{
peakTime = nodeGroupOther.GetSchedulingPeakTimes(document, algorithm, replicateNum, replicateFilter);
if (peakTime != null)
predictedRT = peakTime.CenterTime;
if (predictedRT.HasValue)
{
windowRT = MeasuredRTWindow.Value;
break;
}
}
}
}
}
// If no retention time yet, and there is a predictor, use the predictor
if (!predictedRT.HasValue && RetentionTime != null && RetentionTime.IsUsable)
{
// but only if not using measured results, or the instrument supports
// variable scheduling windows
if (!useMeasured || !singleWindow || MeasuredRTWindow == RetentionTime.TimeWindow)
{
string modifiedSequence = document.Settings.GetSourceTextId(nodePep);
if (null != replicateFilter && document.Settings.HasResults)
{
var retentionTimes = new List<double>();
foreach (var chromSet in document.Settings.MeasuredResults.Chromatograms)
{
if (!replicateFilter(chromSet))
{
continue;
}
foreach (ChromFileInfo chromFileInfo in chromSet.MSDataFileInfos)
{
var conversion = RetentionTime.GetConversion(chromFileInfo.FileId);
if (null == conversion)
{
continue;
}
double? time = RetentionTime.GetRetentionTime(modifiedSequence, conversion);
if (time.HasValue)
{
retentionTimes.Add(time.Value);
}
}
}
if (retentionTimes.Count > 0)
{
predictedRT = retentionTimes.Average();
}
}
if (!predictedRT.HasValue)
{
predictedRT = RetentionTime.GetRetentionTime(modifiedSequence);
}
windowRT = RetentionTime.TimeWindow;
}
}
return predictedRT;
}
