public void Validate(IEnumerable <IsobaricItem> items)
{
List <double> logratio = new List <double>();
foreach (var item in items)
{
var r1 = refFunc1.GetValue(item);
var r2 = refFunc2.GetValue(item);
item.Valid = r1 > ITraqConsts.NULL_INTENSITY && r2 > ITraqConsts.NULL_INTENSITY;
if (item.Valid)
{
logratio.Add(Math.Log(r1 / r2));
}
}
if (logratio.Count > 1)
{
MeanStandardDeviation acc = new MeanStandardDeviation(logratio);
var nd = new Normal(acc.Mean, acc.StdDev);
foreach (var item in items)
{
if (item.Valid)
{
var r1 = refFunc1.GetValue(item);
var r2 = refFunc2.GetValue(item);
var logr = Math.Log(r1 / r2);
item.ValidProbability = nd.TwoTailProbability(logr);
item.Valid = item.ValidProbability >= minProbability;
}
}
}
}
private static void AddFilter(List <FilterItem> items, List <double> iso, double offset, int sigmaFold)
{
if (iso.Count > 0)
{
MeanStandardDeviation acc = new MeanStandardDeviation(iso.ToArray());
items.Add(new FilterItem()
{
Offset = offset,
Mean = acc.Mean,
Sigma = acc.StdDev,
SigmaFold = sigmaFold
});
}
}
public static void CalculatePValue(List <LSPADItem> items)
{
items.Sort((m1, m2) => m1.Intensity.CompareTo(m2.Intensity));
var oneSix = items.Count / 6;
List <double> ratios = new List <double>();
for (int i = 0; i < oneSix; i++)
{
ratios.Add(items[i].LogRatio);
}
int lastOne = 0;
int firstOne = oneSix - 1;
for (int i = 0; i < items.Count; i++)
{
int first = Math.Min(i + oneSix, items.Count);
int last = Math.Max(i - oneSix, 1);
for (int a = lastOne; a < last; a++)
{
ratios.RemoveAt(0);
}
for (int a = firstOne; a < first; a++)
{
ratios.Add(items[a].LogRatio);
}
var acc = new MeanStandardDeviation(ratios);
items[i].Mean = acc.Mean;
items[i].SD = acc.StdDev;
Normal nd = new Normal(acc.Mean, acc.StdDev);
items[i].PValue = nd.CumulativeDistribution(items[i].LogRatio);
items[i].PValue = Math.Min(items[i].PValue, 1 - items[i].PValue);
}
}
public void Recalculate()
{
if (this.peptides.Count == 0)
{
SpectraCount = 0;
PeptideNumber = 0;
AverageRatio = 0;
StandardDeviation = 0;
WeightedAverage = 0;
return;
}
SpectraCount = this.peptides.Count;
var pepSeqs = new HashSet <string>();
foreach (CensusPeptideItem item in this.peptides)
{
pepSeqs.Add(PeptideUtils.GetPureSequence(item.Sequence));
}
PeptideNumber = pepSeqs.Count;
var pepRatio = new List <double>();
double sumWeightedRatio = 0.0;
double sumWeighted = 0.0;
foreach (CensusPeptideItem item in this.peptides)
{
if (item.Ratio == -1 || item.Ratio == 0)
{
continue;
}
//if (item.Enabled)
{
pepRatio.Add(item.Ratio);
sumWeightedRatio += item.Ratio * item.DeterminantFactor;
sumWeighted += item.DeterminantFactor;
}
}
var acc = new MeanStandardDeviation((IEnumerable <double>)pepRatio);
AverageRatio = acc.Mean;
if (double.IsNaN(acc.StdDev) || double.IsInfinity(acc.StdDev))
{
StandardDeviation = 0.0;
}
else
{
StandardDeviation = acc.StdDev;
}
if (sumWeighted != 0)
{
WeightedAverage = sumWeightedRatio / sumWeighted;
}
else
{
WeightedAverage = 0.0;
}
}
public void ValidateScans(SilacCompoundInfo sci, double ppmTolerance)
{
int lightMaxIndex = LightProfile.FindMaxIndex();
int heavyMaxIndex = HeavyProfile.FindMaxIndex();
var identified = ObservedEnvelopes.FindAll(m => m.IsIdentified);
int minIdentifiedScan = identified.Min(m => m.Scan);
int maxIdentifiedScan = identified.Max(m => m.Scan);
ObservedEnvelopes.ForEach(m => m.Enabled = m.Scan >= minIdentifiedScan && m.Scan <= maxIdentifiedScan);
int enabledCount = ObservedEnvelopes.FindAll(m => m.Enabled).Count;
if (enabledCount < 5)
{
int preEnabled = (5 - enabledCount) / 2;
if (preEnabled == 0)
{
preEnabled = 1;
}
int postEnabled = 5 - enabledCount - preEnabled;
int first = ObservedEnvelopes.FindIndex(m => m.Enabled);
for (int i = first - 1; i >= 0 && i >= first - preEnabled; i--)
{
ObservedEnvelopes[i].Enabled = true;
}
int last = ObservedEnvelopes.FindLastIndex(m => m.Enabled);
for (int i = last + 1; i < ObservedEnvelopes.Count && i <= last + postEnabled; i++)
{
ObservedEnvelopes[i].Enabled = true;
}
}
var enabled = ObservedEnvelopes.FindAll(m => m.Enabled);
var lightAccumulator = new MeanStandardDeviation(from ob in enabled
let ppm = PrecursorUtils.mz2ppm(sci.Light.Profile[lightMaxIndex].Mz, sci.Light.Profile[lightMaxIndex].Mz - ob.Light[lightMaxIndex].Mz)
select ppm);
var heavyAccumulator = new MeanStandardDeviation(from ob in enabled
let ppm = PrecursorUtils.mz2ppm(sci.Heavy.Profile[heavyMaxIndex].Mz, sci.Heavy.Profile[heavyMaxIndex].Mz - ob.Heavy[heavyMaxIndex].Mz)
select ppm);
double lightPPM = Math.Max(ppmTolerance, lightAccumulator.StdDev * 3);
double heavyPPM = Math.Max(ppmTolerance, heavyAccumulator.StdDev * 3);
var lightMinPPM = lightAccumulator.Mean - lightPPM;
var lightMaxPPM = lightAccumulator.Mean + lightPPM;
var heavyMinPPM = heavyAccumulator.Mean - heavyPPM;
var heavyMaxPPM = heavyAccumulator.Mean + heavyPPM;
int fixedIndex = ObservedEnvelopes.FindIndex(m => m.IsIdentified);
for (int i = fixedIndex; i >= 0; i--)
{
var pair = ObservedEnvelopes[i];
if (pair.Enabled)
{
continue;
}
if (!AcceptScan(pair, sci, lightMaxIndex, lightMinPPM, lightMaxPPM, heavyMaxIndex, heavyMinPPM, heavyMaxPPM))
{
break;
}
pair.Enabled = true;
}
for (int i = fixedIndex; i < ObservedEnvelopes.Count; i++)
{
var pair = ObservedEnvelopes[i];
if (pair.Enabled)
{
continue;
}
if (!AcceptScan(pair, sci, lightMaxIndex, lightMinPPM, lightMaxPPM, heavyMaxIndex, heavyMinPPM, heavyMaxPPM))
{
break;
}
pair.Enabled = true;
}
}
private static double CalculateFFT(double[] _experimentalIntensities, double[] theoreticalIntensities)
{
var values = new double[151];
{
double value = 0.0;
for (int i = 0; i < _experimentalIntensities.Length; i++)
{
value += _experimentalIntensities[i] * theoreticalIntensities[i];
}
if (value == 0.0)
{
return(0.0);
}
values[75] = value;
}
for (int shift = -75; shift < 0; shift++)
{
int eFrom = -shift;
int eEnd = _experimentalIntensities.Length + shift;
int tFrom = 0;
double value = 0.0;
while (eFrom < eEnd)
{
value += _experimentalIntensities[eFrom] * theoreticalIntensities[tFrom];
eFrom++;
tFrom++;
}
values[75 + shift] = value;
}
for (int shift = 1; shift <= 75; shift++)
{
int eFrom = 0;
int eEnd = _experimentalIntensities.Length - shift;
int tFrom = shift;
double value = 0.0;
while (eFrom < eEnd)
{
value += _experimentalIntensities[eFrom] * theoreticalIntensities[tFrom];
eFrom++;
tFrom++;
}
values[75 + shift] = value;
}
//for (int i = 0; i < values.Length; i++)
//{
// Console.Out.WriteLine("{0}\t{1}", i - 75, values[i]);
//}
var acc = new MeanStandardDeviation(values);
double mean = acc.Mean;
if (acc.Mean == 0)
{
return(0);
}
else
{
return(values[75] / mean);
}
}
public static void ProcessConfiguration(PrecursorReproducibitityConfiguration conf, string resultFileName)
{
List <PrecursorItemList> items = new List <PrecursorItemList>();
var reader = new PrecursorItemListExcelReader();
foreach (var file in conf.FileNames)
{
items.Add(reader.ReadFromFile(file));
}
items.ForEach(m => m.Sort((n1, n2) => - n1.Abundance.CompareTo(n2.Abundance)));
using (StreamWriter sw = new StreamWriter(resultFileName))
{
for (int i = 0; i < items.Count; i++)
{
var itemI = items[i];
var fileI = new FileInfo(conf.FileNames[i]).Name;
itemI.ForEach(m => m.Matched = false);
for (int j = i + 1; j < items.Count; j++)
{
var itemJ = items[j];
var fileJ = new FileInfo(conf.FileNames[j]).Name;
itemJ.ForEach(m => m.Matched = false);
List <PairItem> unions = new List <PairItem>();
foreach (var m in itemI)
{
var matched = (from n in itemJ
where (!n.Matched) && (PrecursorUtils.mz2ppm(m.Mz, Math.Abs(m.Mz - n.Mz)) < conf.PPMTolerance)
select n).ToList();
if (matched.Count > 0)
{
matched.Sort((m1, m2) => Math.Abs(m1.RetentionTime - m.RetentionTime).CompareTo(Math.Abs(m2.RetentionTime - m.RetentionTime)));
matched[0].Matched = true;
m.Matched = true;
unions.Add(new PairItem()
{
Item1 = m,
Item2 = matched[0],
Used = false
});
}
}
var rts = (from u in unions
orderby u.RetentionTimeDiff
select u).ToList();
//keep 90% to do statistic.
int count = rts.Count / 20;
rts = rts.Take(rts.Count - count).Skip(count).ToList();
rts.ForEach(m => m.Used = true);
sw.WriteLine("{0} vs {1}\tmatched {2}", fileI, fileJ, rts.Count);
var acc = new MeanStandardDeviation(rts.ConvertAll(m => m.RetentionTimeDiff).ToArray());
sw.WriteLine("RETENTION TIME : Mean = {0:0.0000}, SD = {1:0.0000}", acc.Mean, acc.StdDev);
var abundances = from u in unions
select u.AbundanceDiff;
acc = new MeanStandardDeviation(abundances.ToArray());
sw.WriteLine("ABUNDANCE : Mean = {0:0.0000}, SD = {1:0.0000}", acc.Mean, acc.StdDev);
sw.WriteLine("MZ\tRT1\tRT2\tABUNDANCE1\tABUNDANCE2\tRTDiff\tAbundanceDiff\tUsed");
unions.Sort((m1, m2) => m1.Mz.CompareTo(m2.Mz));
unions.ForEach(m => sw.WriteLine("{0:0.0000}\t{1:0.0000}\t{2:0.0000}\t{3:0.0000}\t{4:0.0000}\t{5:0.0000}\t{6:0.0000}\t{7}",
m.Mz,
m.Item1.RetentionTime,
m.Item2.RetentionTime,
m.Item1.Abundance,
m.Item2.Abundance,
m.RetentionTimeDiff,
m.AbundanceDiff,
m.Used));
WriteOnlyItem(sw, itemI, fileI + " only");
WriteOnlyItem(sw, itemJ, fileJ + " only");
}
}
}
}
private double GetRsd(IsobaricItem item, int index1, int index2)
{
var acc = new MeanStandardDeviation(new double[] { item[index1], item[index2] });
return(acc.StdDev / acc.Mean);
}
