private void RelativeElutionTime(TracerFormula tracerFormulaStd, TracerFormula tracerFormula, out int eluteBefore, out int eluteAfter)
{
eluteBefore = eluteAfter = 0;
foreach (var tracerDef in PeptideAnalysis.Workspace.GetTracerDefs())
{
int diff = tracerFormula.GetElementCount(tracerDef.Name) - tracerFormulaStd.GetElementCount(tracerDef.Name);
if (diff == 0)
{
continue;
}
if (tracerDef.IsotopesEluteEarlier)
{
if (diff > 0)
{
eluteBefore += diff;
}
else
{
eluteAfter -= diff;
}
}
if (tracerDef.IsotopesEluteLater)
{
if (diff > 0)
{
eluteAfter += diff;
}
else
{
eluteBefore -= diff;
}
}
}
}
private LinearRegression GetLinearRegression(TracerFormula targetTracerFormula, double startTime, double endTime)
{
var baseStats = new Statistics(GetBaseValues());
var targetStats = new Statistics(GetValues(targetTracerFormula, startTime, endTime));
return(Statistics.LinearRegressionWithErrorsInBothCoordinates(baseStats, targetStats));
}
public Peak?GetPeak(TracerFormula tracerFormula)
{
Peak peak;
if (tracerFormula == null || !_peaks.TryGetValue(tracerFormula, out peak))
{
return(null);
}
return(peak);
}
private void MakeBasePeak(TracerFormula tracerFormula, double startTime, double endTime)
{
var result = MakePeak(tracerFormula, startTime, endTime);
result.Intercept = 0;
result.RatioToBase = 1;
result.RatioToBaseError = 0;
result.Correlation = 1;
BasePeakKey = tracerFormula;
_peaks[tracerFormula] = result;
}
public double GetMaxIntensity(TracerFormula tracerFormula, int startIndex, int endIndex)
{
var points = Points[tracerFormula];
double result = 0;
for (int i = startIndex; i <= endIndex; i++)
{
result = Math.Max(result, points[i]);
}
return(result);
}
private void MakeSecondaryPeak(TracerFormula tracerFormula, double startTime, double endTime)
{
var result = MakePeak(tracerFormula, startTime, endTime);
var linearRegression = GetLinearRegression(tracerFormula, startTime, endTime);
result.Intercept = linearRegression.Intercept;
result.RatioToBase = linearRegression.Slope;
result.RatioToBaseError = linearRegression.SlopeError;
result.Correlation = linearRegression.Correlation;
_peaks[tracerFormula] = result;
}
private Peak MakePeak(TracerFormula tracerFormula, double startTime, double endTime)
{
var result = new Peak
{
StartTime = startTime,
EndTime = endTime,
TotalArea = GetTracerChromatograms().GetArea(tracerFormula, startTime, endTime),
TracerPercent = PeptideFileAnalysis.TurnoverCalculator.GetTracerPercent(tracerFormula),
Background = GetTracerChromatograms().GetBackground(tracerFormula, startTime, endTime),
};
return(result);
}
private bool IsDisplayed(TracerFormula tracerFormula)
{
if (dataGridView1.SelectedRows.Count == 0)
{
return(true);
}
for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
var row = dataGridView1.Rows[i];
if (row.Selected && tracerFormula.Equals(row.Tag))
{
return(true);
}
}
return(false);
}
public CalculatedPeaks AutoSizePeak(TracerFormula tracerFormula, AdjustPeaksMode adjustPeaksMode)
{
if (tracerFormula.Equals(BasePeakKey))
{
return(this);
}
var result = new CalculatedPeaks(PeptideFileAnalysis)
{
AutoFindPeak = false,
};
var oldBasePeak = _peaks[BasePeakKey];
result.MakeBasePeak(BasePeakKey, oldBasePeak.StartTime, oldBasePeak.EndTime);
foreach (var entry in _peaks)
{
if (entry.Key.Equals(BasePeakKey))
{
continue;
}
Peak?newPeak = null;
if (entry.Key.Equals(tracerFormula))
{
double width = oldBasePeak.EndTime - oldBasePeak.StartTime;
if (adjustPeaksMode == AdjustPeaksMode.Full)
{
newPeak = result.FindMatchingPeak(tracerFormula);
}
else if (adjustPeaksMode == AdjustPeaksMode.Overlapping)
{
newPeak = result.FindMatchingPeak(tracerFormula, entry.Value.StartTime - width, entry.Value.EndTime + width);
}
else if (adjustPeaksMode == AdjustPeaksMode.Narrow)
{
newPeak = result.FindMatchingPeak(tracerFormula,
Math.Min(entry.Value.StartTime, entry.Value.EndTime - width),
Math.Max(entry.Value.EndTime, entry.Value.StartTime + width));
}
}
if (newPeak == null)
{
result.MakeSecondaryPeak(entry.Key, entry.Value.StartTime, entry.Value.EndTime);
}
}
result.FinishCalculation();
return(result);
}
private Peak FindMatchingPeak(TracerFormula targetTracerFormula, double minStartTime, double maxEndTime)
{
var tracerChromatograms = GetTracerChromatograms();
var basePeak = _peaks[BasePeakKey];
double width = basePeak.EndTime - basePeak.StartTime;
var linearRegressions = new List <LinearRegressionEntry>();
double minCorrelationCoeff = Workspace.GetMinCorrelationCoefficient();
for (int offset = 0; offset < tracerChromatograms.Times.Count; offset++)
{
double startTime = tracerChromatograms.Times[offset];
if (startTime < minStartTime)
{
continue;
}
double endTime = startTime + width;
if (endTime > tracerChromatograms.Times[tracerChromatograms.Times.Count - 1] || endTime > maxEndTime)
{
break;
}
var linearRegression = GetLinearRegression(targetTracerFormula, startTime, endTime);
linearRegressions.Add(new LinearRegressionEntry(startTime, endTime, linearRegression));
}
var localMaxima = new List <LinearRegressionEntry>(
linearRegressions.Where(
(e, i) => (i == 0 || e.Correlation >= linearRegressions[i - 1].Correlation)
&&
(i == linearRegressions.Count - 1 ||
e.Correlation > linearRegressions[i + 1].Correlation)));
localMaxima.Sort((e1, e2) => e1.GetDistanceTo(basePeak).CompareTo(e2.GetDistanceTo(basePeak)));
var bestEntry = localMaxima.FirstOrDefault(e => e.Correlation > minCorrelationCoeff);
if (bestEntry == null)
{
localMaxima.Sort((e1, e2) => e1.Correlation.CompareTo(e2.Correlation));
bestEntry = localMaxima[localMaxima.Count - 1];
}
MakeSecondaryPeak(targetTracerFormula, bestEntry.StartTime, bestEntry.EndTime);
return(_peaks[targetTracerFormula]);
}
public void Test58Percent()
{
var path = Path.Combine(TestContext.TestDir, Guid.NewGuid().ToString() + ".tpg");
var workspace = CreateWorkspace(path, TracerDef.GetD3LeuEnrichment());
var turnoverCalculator = new TurnoverCalculator(workspace, "LL");
var dict = new Dictionary <TracerFormula, double>();
// initialize the dictionary with 70% newly synthesized from 58% precursor pool
dict.Add(TracerFormula.Parse("Tracer2"), Math.Pow(.58, 2) * .7);
dict.Add(TracerFormula.Parse("Tracer1"), 2 * .58 * .42 * .7);
dict.Add(TracerFormula.Empty, 1 - dict.Values.Sum());
double turnover;
double turnoverScore;
IDictionary <TracerFormula, double> bestMatch;
var precursorEnrichment = turnoverCalculator.ComputePrecursorEnrichmentAndTurnover(dict, out turnover, out turnoverScore, out bestMatch);
Assert.AreEqual(.7, turnover);
Assert.AreEqual(58, precursorEnrichment["Tracer"]);
}
public double GetArea(TracerFormula tracerFormula, double startTime, double endTime)
{
double result = 0;
int startIndex = ChromatogramSet.IndexFromTime(startTime);
int endIndex = ChromatogramSet.IndexFromTime(endTime);
for (int i = startIndex; i <= endIndex; i++)
{
int binStartIndex = Math.Max(i - 1, 0);
int binEndIndex = Math.Min(i + 1, Times.Count - 1);
if (binStartIndex == binEndIndex)
{
continue;
}
double width = (Times[binEndIndex] - Times[binStartIndex]) / (binEndIndex - binStartIndex);
result += Points[tracerFormula][i] * width;
}
return(result);
}
private Peak FindMatchingPeak(TracerFormula targetTracerFormula)
{
var basePeak = _peaks[BasePeakKey];
double retentionTimeShift = Workspace.GetMaxIsotopeRetentionTimeShift();
double minStartTime = basePeak.StartTime;
double maxEndTime = basePeak.EndTime;
int eluteBefore, eluteAfter;
RelativeElutionTime(BasePeakKey, targetTracerFormula, out eluteBefore, out eluteAfter);
if (eluteBefore > 0)
{
minStartTime -= retentionTimeShift;
}
if (eluteAfter > 0)
{
maxEndTime += retentionTimeShift;
}
return(FindMatchingPeak(targetTracerFormula, minStartTime, maxEndTime));
}
public double[] GetValues(TracerFormula tracerFormula, double startTime, double endTime)
{
var tracerChromatograms = GetTracerChromatograms();
var chromatograms = tracerChromatograms.ChromatogramSet;
var basePeak = _peaks[BasePeakKey];
int baseStartIndex = chromatograms.IndexFromTime(basePeak.StartTime);
int baseEndIndex = chromatograms.IndexFromTime(basePeak.EndTime);
double[] points = new double[baseEndIndex - baseStartIndex + 1];
var allPoints = tracerChromatograms.Points[tracerFormula];
for (int i = baseStartIndex; i <= baseEndIndex; i++)
{
double baseTime = chromatograms.Times[i];
double time = (startTime * (baseTime - basePeak.StartTime) + endTime * (basePeak.EndTime - baseTime))
/ (basePeak.EndTime - basePeak.StartTime);
double prevTime;
int index = chromatograms.IndexFromTime(time);
double nextTime = chromatograms.Times[index];
if (index > 0)
{
prevTime = chromatograms.Times[index - 1];
}
else
{
prevTime = nextTime;
}
double value;
if (nextTime < time || prevTime >= nextTime)
{
value = allPoints[index];
}
else
{
double nextValue = allPoints[index];
double prevValue = allPoints[index - 1];
value = (nextValue * (time - prevTime) + prevValue * (nextTime - time)) / (nextTime - prevTime);
}
points[i - baseStartIndex] = value;
}
return(points);
}
public CalculatedPeaks ChangeBasePeak(TracerFormula baseTracerFormula)
{
CalculatedPeaks result = new CalculatedPeaks(PeptideFileAnalysis)
{
AutoFindPeak = false,
};
var basePeak = _peaks[baseTracerFormula];
result.MakeBasePeak(baseTracerFormula, basePeak.StartTime, basePeak.EndTime);
foreach (var entry in _peaks)
{
if (entry.Key.Equals(baseTracerFormula))
{
continue;
}
result.MakeSecondaryPeak(entry.Key, entry.Value.StartTime, entry.Value.EndTime);
}
result.FinishCalculation();
return(result);
}
public CalculatedPeaks ChangeTime(TracerFormula tracerFormula, double newStartTime, double newEndTime)
{
CalculatedPeaks result = new CalculatedPeaks(PeptideFileAnalysis)
{
AutoFindPeak = false,
};
Peak oldBasePeak = _peaks[BasePeakKey];
bool isBasePeak;
if (tracerFormula.Equals(BasePeakKey))
{
result.MakeBasePeak(BasePeakKey, newStartTime, newEndTime);
isBasePeak = true;
}
else
{
result.MakeBasePeak(BasePeakKey, oldBasePeak.StartTime,
oldBasePeak.EndTime);
isBasePeak = false;
}
foreach (var entry in _peaks)
{
if (entry.Key.Equals(tracerFormula))
{
if (isBasePeak)
{
continue;
}
result.MakeSecondaryPeak(tracerFormula, newStartTime, newEndTime);
}
else
{
result.MakeSecondaryPeak(entry.Key, entry.Value.StartTime, entry.Value.EndTime);
}
}
result.FinishCalculation();
return(result);
}
public double[] GetValues(TracerFormula tracerFormula, double startTime, double endTime)
{
var tracerChromatograms = GetTracerChromatograms();
var chromatograms = tracerChromatograms.ChromatogramSet;
var basePeak = _peaks[BasePeakKey];
int baseStartIndex = chromatograms.IndexFromTime(basePeak.StartTime);
int baseEndIndex = chromatograms.IndexFromTime(basePeak.EndTime);
double[] points = new double[baseEndIndex - baseStartIndex + 1];
var allPoints = tracerChromatograms.Points[tracerFormula];
for (int i = baseStartIndex; i <= baseEndIndex; i++)
{
double baseTime = chromatograms.Times[i];
double time = (startTime * (baseTime - basePeak.StartTime) + endTime * (basePeak.EndTime - baseTime))
/ (basePeak.EndTime - basePeak.StartTime);
double prevTime;
int index = chromatograms.IndexFromTime(time);
double nextTime = chromatograms.Times[index];
if (index > 0)
{
prevTime = chromatograms.Times[index - 1];
}
else
{
prevTime = nextTime;
}
double value;
if (nextTime < time || prevTime >= nextTime)
{
value = allPoints[index];
}
else
{
double nextValue = allPoints[index];
double prevValue = allPoints[index - 1];
value = (nextValue*(time - prevTime) + prevValue*(nextTime - time))/(nextTime - prevTime);
}
points[i - baseStartIndex] = value;
}
return points;
}
public Peak? GetPeak(TracerFormula tracerFormula)
{
Peak peak;
if (tracerFormula == null || !_peaks.TryGetValue(tracerFormula, out peak))
{
return null;
}
return peak;
}
public CalculatedPeaks ChangeTime(TracerFormula tracerFormula, double newStartTime, double newEndTime)
{
CalculatedPeaks result = new CalculatedPeaks(PeptideFileAnalysis)
{
AutoFindPeak = false,
};
Peak oldBasePeak = _peaks[BasePeakKey];
bool isBasePeak;
if (tracerFormula.Equals(BasePeakKey))
{
result.MakeBasePeak(BasePeakKey, newStartTime, newEndTime);
isBasePeak = true;
}
else
{
result.MakeBasePeak(BasePeakKey, oldBasePeak.StartTime,
oldBasePeak.EndTime);
isBasePeak = false;
}
foreach (var entry in _peaks)
{
if (entry.Key.Equals(tracerFormula))
{
if (isBasePeak)
{
continue;
}
result.MakeSecondaryPeak(tracerFormula, newStartTime, newEndTime);
}
else
{
result.MakeSecondaryPeak(entry.Key, entry.Value.StartTime, entry.Value.EndTime);
}
}
result.FinishCalculation();
return result;
}
public CalculatedPeaks ChangeBasePeak(TracerFormula baseTracerFormula)
{
CalculatedPeaks result = new CalculatedPeaks(PeptideFileAnalysis)
{
AutoFindPeak = false,
};
var basePeak = _peaks[baseTracerFormula];
result.MakeBasePeak(baseTracerFormula, basePeak.StartTime, basePeak.EndTime);
foreach (var entry in _peaks)
{
if (entry.Key.Equals(baseTracerFormula))
{
continue;
}
result.MakeSecondaryPeak(entry.Key, entry.Value.StartTime, entry.Value.EndTime);
}
result.FinishCalculation();
return result;
}
public CalculatedPeaks AutoSizePeak(TracerFormula tracerFormula, AdjustPeaksMode adjustPeaksMode)
{
if (tracerFormula.Equals(BasePeakKey))
{
return this;
}
var result = new CalculatedPeaks(PeptideFileAnalysis)
{
AutoFindPeak = false,
};
var oldBasePeak = _peaks[BasePeakKey];
result.MakeBasePeak(BasePeakKey, oldBasePeak.StartTime, oldBasePeak.EndTime);
foreach (var entry in _peaks)
{
if (entry.Key.Equals(BasePeakKey))
{
continue;
}
Peak? newPeak = null;
if (entry.Key.Equals(tracerFormula))
{
double width = oldBasePeak.EndTime - oldBasePeak.StartTime;
if (adjustPeaksMode == AdjustPeaksMode.Full)
{
newPeak = result.FindMatchingPeak(tracerFormula);
}
else if (adjustPeaksMode == AdjustPeaksMode.Overlapping)
{
newPeak = result.FindMatchingPeak(tracerFormula, entry.Value.StartTime - width, entry.Value.EndTime + width);
}
else if (adjustPeaksMode == AdjustPeaksMode.Narrow)
{
newPeak = result.FindMatchingPeak(tracerFormula,
Math.Min(entry.Value.StartTime, entry.Value.EndTime - width),
Math.Max(entry.Value.EndTime, entry.Value.StartTime + width));
}
}
if (newPeak == null)
{
result.MakeSecondaryPeak(entry.Key, entry.Value.StartTime, entry.Value.EndTime);
}
}
result.FinishCalculation();
return result;
}
private void RelativeElutionTime(TracerFormula tracerFormulaStd, TracerFormula tracerFormula, out int eluteBefore, out int eluteAfter)
{
eluteBefore = eluteAfter = 0;
foreach (var tracerDef in PeptideAnalysis.Workspace.GetTracerDefs())
{
int diff = tracerFormula.GetElementCount(tracerDef.Name) - tracerFormulaStd.GetElementCount(tracerDef.Name);
if (diff == 0)
{
continue;
}
if (tracerDef.IsotopesEluteEarlier)
{
if (diff > 0)
{
eluteBefore+=diff;
}
else
{
eluteAfter-=diff;
}
}
if (tracerDef.IsotopesEluteLater)
{
if (diff > 0)
{
eluteAfter+=diff;
}
else
{
eluteBefore-=diff;
}
}
}
}
private Peak MakePeak(TracerFormula tracerFormula, double startTime, double endTime)
{
var result = new Peak
{
StartTime = startTime,
EndTime = endTime,
TotalArea = GetTracerChromatograms().GetArea(tracerFormula, startTime, endTime),
TracerPercent = PeptideFileAnalysis.TurnoverCalculator.GetTracerPercent(tracerFormula),
Background = GetTracerChromatograms().GetBackground(tracerFormula, startTime, endTime),
};
return result;
}
private LinearRegression GetLinearRegression(TracerFormula targetTracerFormula, double startTime, double endTime)
{
var baseStats = new Statistics(GetBaseValues());
var targetStats = new Statistics(GetValues(targetTracerFormula, startTime, endTime));
return Statistics.LinearRegressionWithErrorsInBothCoordinates(baseStats, targetStats);
}
private Peak FindMatchingPeak(TracerFormula targetTracerFormula)
{
var basePeak = _peaks[BasePeakKey];
double retentionTimeShift = Workspace.GetMaxIsotopeRetentionTimeShift();
double minStartTime = basePeak.StartTime;
double maxEndTime = basePeak.EndTime;
int eluteBefore, eluteAfter;
RelativeElutionTime(BasePeakKey, targetTracerFormula, out eluteBefore, out eluteAfter);
if (eluteBefore > 0)
{
minStartTime -= retentionTimeShift;
}
if (eluteAfter > 0)
{
maxEndTime += retentionTimeShift;
}
return FindMatchingPeak(targetTracerFormula, minStartTime, maxEndTime);
}
public double GetMaxIntensity(TracerFormula tracerFormula, int startIndex, int endIndex)
{
var points = Points[tracerFormula];
double result = 0;
for (int i = startIndex; i <= endIndex; i++)
{
result = Math.Max(result, points[i]);
}
return result;
}
public double[] GetValues(DbPeak dbPeak)
{
return(GetValues(TracerFormula.Parse(dbPeak.Name), dbPeak.StartTime, dbPeak.EndTime));
}
public double GetBackground(TracerFormula tracerFormula, double startTime, double endTime)
{
return 0;
}
private Peak FindMatchingPeak(TracerFormula targetTracerFormula, double minStartTime, double maxEndTime)
{
var tracerChromatograms = GetTracerChromatograms();
var basePeak = _peaks[BasePeakKey];
double width = basePeak.EndTime - basePeak.StartTime;
var linearRegressions = new List<LinearRegressionEntry>();
double minCorrelationCoeff = Workspace.GetMinCorrelationCoefficient();
for (int offset = 0; offset < tracerChromatograms.Times.Count; offset ++)
{
double startTime = tracerChromatograms.Times[offset];
if (startTime < minStartTime)
{
continue;
}
double endTime = startTime + width;
if (endTime > tracerChromatograms.Times[tracerChromatograms.Times.Count - 1] || endTime > maxEndTime)
{
break;
}
var linearRegression = GetLinearRegression(targetTracerFormula, startTime, endTime);
linearRegressions.Add(new LinearRegressionEntry(startTime, endTime, linearRegression));
}
var localMaxima = new List<LinearRegressionEntry>(
linearRegressions.Where(
(e, i) => (i == 0 || e.Correlation >= linearRegressions[i - 1].Correlation)
&&
(i == linearRegressions.Count - 1 ||
e.Correlation > linearRegressions[i + 1].Correlation)));
localMaxima.Sort((e1,e2)=>e1.GetDistanceTo(basePeak).CompareTo(e2.GetDistanceTo(basePeak)));
var bestEntry = localMaxima.FirstOrDefault(e => e.Correlation > minCorrelationCoeff);
if (bestEntry == null)
{
localMaxima.Sort((e1,e2)=>e1.Correlation.CompareTo(e2.Correlation));
bestEntry = localMaxima[localMaxima.Count - 1];
}
MakeSecondaryPeak(targetTracerFormula, bestEntry.StartTime, bestEntry.EndTime);
return _peaks[targetTracerFormula];
}
public double GetArea(TracerFormula tracerFormula, double startTime, double endTime)
{
double result = 0;
int startIndex = ChromatogramSet.IndexFromTime(startTime);
int endIndex = ChromatogramSet.IndexFromTime(endTime);
for (int i = startIndex; i<= endIndex; i++)
{
int binStartIndex = Math.Max(i - 1, 0);
int binEndIndex = Math.Min(i + 1, Times.Count - 1);
if (binStartIndex == binEndIndex)
{
continue;
}
double width = (Times[binEndIndex] - Times[binStartIndex])/(binEndIndex - binStartIndex);
result += Points[tracerFormula][i] * width;
}
return result;
}
private void MakeBasePeak(TracerFormula tracerFormula, double startTime, double endTime)
{
var result = MakePeak(tracerFormula, startTime, endTime);
result.Intercept = 0;
result.RatioToBase = 1;
result.RatioToBaseError = 0;
result.Correlation = 1;
BasePeakKey = tracerFormula;
_peaks[tracerFormula] = result;
}
public double GetBackground(TracerFormula tracerFormula, double startTime, double endTime)
{
return(0);
}
private void MakeSecondaryPeak(TracerFormula tracerFormula, double startTime, double endTime)
{
var result = MakePeak(tracerFormula, startTime, endTime);
var linearRegression = GetLinearRegression(tracerFormula, startTime, endTime);
result.Intercept = linearRegression.Intercept;
result.RatioToBase = linearRegression.Slope;
result.RatioToBaseError = linearRegression.SlopeError;
result.Correlation = linearRegression.Correlation;
_peaks[tracerFormula] = result;
}
private bool IsDisplayed(TracerFormula tracerFormula)
{
if (dataGridView1.SelectedRows.Count == 0)
{
return true;
}
for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
var row = dataGridView1.Rows[i];
if (row.Selected && tracerFormula.Equals(row.Tag))
{
return true;
}
}
return false;
}
private void UpdateGraph()
{
if (_inUpdateGraph)
{
return;
}
try
{
_inUpdateGraph = true;
_msGraphControl.GraphPane.GraphObjList.Clear();
_msGraphControl.GraphPane.CurveList.Clear();
dataGridView1.Rows.Clear();
int charge;
try
{
charge = Convert.ToInt32(tbxCharge.Text);
tbxCharge.BackColor = Color.White;
}
catch
{
charge = 0;
tbxCharge.BackColor = Color.Red;
}
double massResolution;
try
{
massResolution = double.Parse(tbxMassResolution.Text);
tbxMassResolution.BackColor = Color.White;
}
catch
{
tbxMassResolution.BackColor = Color.Red;
massResolution = .01;
}
var sequence = tbxSequence.Text;
MassDistribution spectrum;
if (string.IsNullOrEmpty(sequence))
{
var formula = tbxFormula.Text;
var molecule = Molecule.Parse(formula);
if (molecule.Values.Sum() > 10000000)
{
tbxFormula.BackColor = Color.Red;
return;
}
try
{
spectrum = Workspace.GetAminoAcidFormulas().GetMassDistribution(molecule, charge);
tbxFormula.BackColor = Color.White;
}
catch
{
tbxFormula.BackColor = Color.Red;
return;
}
}
else
{
tbxFormula.Text = Workspace.GetAminoAcidFormulas().GetFormula(sequence).ToString();
var turnoverCalculator = new TurnoverCalculator(Workspace, sequence);
var aminoAcidFormulas = Workspace.GetAminoAcidFormulasWithTracers();
aminoAcidFormulas = aminoAcidFormulas.SetMassResolution(massResolution);
try
{
if (cbxTracerPercents.Checked)
{
var tracerPercentFormula = TracerPercentFormula.Parse(tbxTracerFormula.Text);
spectrum = turnoverCalculator.GetAminoAcidFormulas(tracerPercentFormula)
.GetMassDistribution(sequence, charge);
}
else
{
var tracerFormula = TracerFormula.Parse(tbxTracerFormula.Text);
spectrum = aminoAcidFormulas.GetMassDistribution(
turnoverCalculator.MoleculeFromTracerFormula(tracerFormula), charge);
double massShift = aminoAcidFormulas.GetMassShift(sequence);
if (charge > 0)
{
massShift /= charge;
}
spectrum = spectrum.OffsetAndDivide(massShift, 1);
}
tbxTracerFormula.BackColor = Color.White;
}
catch
{
tbxTracerFormula.BackColor = Color.Red;
spectrum = aminoAcidFormulas.GetMassDistribution(sequence, charge);
}
}
if (spectrum == null)
{
return;
}
var curveItem = _msGraphControl.AddGraphItem(_msGraphControl.GraphPane, new GraphItem
{
Title = "Intensity",
Color = Color.Black,
Points =
new PointPairList(
spectrum.Keys.
ToArray(),
spectrum.Values.
ToArray())
});
curveItem.Label.IsVisible = false;
_msGraphControl.AxisChange();
_msGraphControl.Invalidate();
var entries = spectrum.ToArray();
dataGridView1.Rows.Add(entries.Length);
for (int i = 0; i < entries.Count(); i++)
{
var row = dataGridView1.Rows[i];
row.Cells[colMass.Index].Value = entries[i].Key;
row.Cells[colIntensity.Index].Value = entries[i].Value;
}
}
finally
{
_inUpdateGraph = false;
}
}
private void BtnGoOnClick(object sender, EventArgs e)
{
graphDetails.GraphPane.CurveList.Clear();
int pointCount = PointCount;
double precursorPool = PrecursorPool;
double turnover = Turnover;
int labelCount = LabelCount;
double noise = Noise;
var points = new PointPairList();
var tracerDef = Workspace.GetTracerDefs().FirstOrDefault(td => td.AminoAcidSymbol.HasValue);
if (tracerDef == null)
{
MessageBox.Show(
"The simulation cannot be run because there is no amino acid tracer defined in this workspace");
return;
}
Debug.Assert(tracerDef.AminoAcidSymbol.HasValue);
string peptide = new string(tracerDef.AminoAcidSymbol.Value, labelCount);
var turnoverCalculator = new TurnoverCalculator(Workspace, peptide);
var initialTracerPercents = TracerPercentFormula.Parse("").SetElementCount(tracerDef.Name, tracerDef.InitialApe);
var newTracerPercents = TracerPercentFormula.Parse("").SetElementCount(tracerDef.Name, precursorPool);
var initialDistribution = turnoverCalculator.GetDistribution(initialTracerPercents);
var newDistribution = turnoverCalculator.GetDistribution(newTracerPercents);
var currentMixture = Mix(initialDistribution, (100.0 - turnover) / 100, newDistribution, turnover / 100);
var keys = new List <TracerFormula>();
for (int i = 0; i <= labelCount; i++)
{
keys.Add(TracerFormula.Parse("").SetElementCount(tracerDef.Name, i));
}
var bestMatches = new List <IDictionary <TracerFormula, double> >();
var precursorEnrichments = new List <TracerPercentFormula>();
var observedResults = new List <IDictionary <TracerFormula, double> >();
while (points.Count < pointCount)
{
var noisyMixture = Perturb(keys, currentMixture, noise / 100);
double calcTurnover;
double calcTurnoverScore;
double calcPrecursorPool;
IDictionary <TracerFormula, double> bestMatch;
var calcMixture = turnoverCalculator.ComputePrecursorEnrichmentAndTurnover(noisyMixture, out calcTurnover, out calcTurnoverScore, out bestMatch);
if (calcMixture == null)
{
continue;
}
calcMixture.TryGetValue(tracerDef.Name, out calcPrecursorPool);
points.Add(new PointPair(calcTurnover * 100, calcPrecursorPool));
bestMatches.Add(bestMatch);
precursorEnrichments.Add(calcMixture);
observedResults.Add(noisyMixture);
}
graphResults.GraphPane.CurveList.Clear();
graphResults.GraphPane.GraphObjList.Clear();
var lineItem = graphResults.GraphPane.AddCurve(null, points, Color.Black);
lineItem.Line.IsVisible = false;
graphResults.GraphPane.XAxis.Title.Text = "% newly synthesized";
graphResults.GraphPane.YAxis.Title.Text = "Precursor pool";
graphResults.GraphPane.AxisChange();
graphResults.Invalidate();
dataGridView.Rows.Clear();
var row = dataGridView.Rows[dataGridView.Rows.Add()];
row.Cells[colQuantity.Index].Value = "% newly synthesized";
var statsTurnover = new Statistics(points.Select(p => p.X).ToArray());
row.Cells[colMean.Index].Value = statsTurnover.Mean();
row.Cells[colMedian.Index].Value = statsTurnover.Median();
row.Cells[colStdDev.Index].Value = statsTurnover.StdDev();
row = dataGridView.Rows[dataGridView.Rows.Add()];
var statsPrecursorPool = new Statistics(points.Select(p => p.Y).ToArray());
row.Cells[colQuantity.Index].Value = "Precursor Pool";
row.Cells[colMean.Index].Value = statsPrecursorPool.Mean();
row.Cells[colMedian.Index].Value = statsPrecursorPool.Median();
row.Cells[colStdDev.Index].Value = statsPrecursorPool.StdDev();
_precursorEnrichmentsByPoint = points.Select(p => p.Y).ToArray();
_bestMatches = bestMatches;
_observedResults = observedResults;
_scatterPlotCurve = lineItem;
_expected = currentMixture;
_turnovers = points.Select(p => p.X).ToArray();
_tracerFormulas = keys;
ShowResult(-1);
}
