public PeakList <T> FindPeak(double mz, int charge, double mzTolerance) { PeakList <T> result = NewSubPeakList(); double minMz = mz - mzTolerance; double maxMz = mz + mzTolerance; foreach (var p in this) { if (p.Mz < minMz) { continue; } if (p.Mz > maxMz) { break; } if (p.Charge != charge) { continue; } result.Add(p); } return(result); }
/// <summary> /// Calculate XCorr based on implementation in MyriMatch /// </summary> /// <param name="pkl1">Normalized peak list 1</param> /// <param name="pkl2">Normalized peak list 2</param> /// <returns></returns> public static double Calculate <T>(PeakList <T> pkl1, PeakList <T> pkl2) where T : IPeak, new() { double massCutOff = Math.Max(pkl1.Last().Mz, pkl2.Last().Mz) + 50; int maxBins = massCutOff > 512 ? (int)Math.Ceiling(massCutOff / 1024) * 1024 : 512; double[] data1 = GetIntensityArray(pkl1, maxBins); //Compute the cumulative spectrum for (int i = 0; i < data1.Length; i++) { for (int j = i - 75; j <= i + 75; j++) { if (IsValidIndex(j, maxBins)) { data1[i] -= data1[j] / 151; } } } double[] data2 = GetIntensityArray(pkl2, maxBins); double result = 0.0; for (int index = 0; index < data1.Length; index++) { result += data1[index] * data2[index]; } result = result / 10000; return(result); }
public void TestMergeWith() { PeakList <Peak> pl1 = new PeakList <Peak>(); pl1.Add(new Peak(420, 10, 1)); pl1.Add(new Peak(445, 10, 1)); PeakList <Peak> pl2 = new PeakList <Peak>(); pl2.Add(new Peak(420.004, 30, 2)); pl2.Add(new Peak(445.004, 30, 1)); pl1.MergeByMZFirst(pl2, 50); Assert.AreEqual(3, pl1.Count); Assert.AreEqual(420, pl1[0].Mz, 0.001); Assert.AreEqual(1, pl1[0].Charge); Assert.AreEqual(420.004, pl1[1].Mz, 0.001); Assert.AreEqual(2, pl1[1].Charge); Assert.AreEqual(445.003, pl1[2].Mz, 0.001); Assert.AreEqual(1, pl1[2].Charge); Assert.AreEqual(10, pl1[0].Intensity); Assert.AreEqual(30, pl1[1].Intensity); Assert.AreEqual(40, pl1[2].Intensity); }
private PeakList <T> NewSubPeakList() { var result = new PeakList <T>(); result.AssignInforamtion(this); return(result); }
public void TestFindPeak() { PeakList <Peak> findPeak = pl.FindPeak(446.12, 0.1); Assert.AreEqual(2, findPeak.Count); Assert.AreSame(pl[2], findPeak[0]); Assert.AreSame(pl[3], findPeak[1]); }
/// <summary> /// Calculate XCorr based on implementation in MyriMatch /// </summary> /// <param name="pkl1">Normalized peak list 1</param> /// <param name="pkl2">Normalized peak list 2</param> /// <returns></returns> public static double CalculateUnnormalized <T>(PeakList <T> pkl1, PeakList <T> pkl2) where T : IPeak, new() { var maxPeakMass = Math.Max(pkl1.Last().Mz, pkl2.Last().Mz); var n1 = NormalizePeakIntensities(pkl1, maxPeakMass); var n2 = NormalizePeakIntensities(pkl2, maxPeakMass); return(Calculate(n1, n2)); }
public void AssignInforamtion <V>(PeakList <V> source) where V : IPeak { this.MsLevel = source.MsLevel; this.Precursor = new PrecursorPeak(source.Precursor); this.Experimental = source.Experimental; this.scanTimes.Clear(); this.scanTimes.AddRange(source.scanTimes); }
public PeakList(PeakList <T> source) : this() { AssignInforamtion <T>(source); AddRange(source); foreach (String key in source.annotations.Keys) { this.annotations.Add(key, source.annotations[key]); } }
/** * For each peak in this peaklist, only the max intensity peak within mzTolerance in argument peakList * will be merged. And, the mz, charge will not be changed, intensity will be added. */ public void AddToCurrentPeakListIntensity(PeakList <T> peakList, double mzTolerance) { foreach (T peak in this) { PeakList <T> find = peakList.FindPeak(peak.Mz, mzTolerance); if (find.Count > 0) { T maxIntensity = find.FindMaxIntensityPeak(); peak.Intensity = peak.Intensity + maxIntensity.Intensity; } } }
public void TestGetRange() { double min = 440; double max = 450; PeakList <Peak> rangePeaks = pl.GetRange(min, max); Assert.AreEqual(4, rangePeaks.Count); foreach (Peak p in rangePeaks) { Assert.Greater(p.Mz, min); Assert.Less(p.Mz, max); } }
private static double[] GetIntensityArray <T>(PeakList <T> pkl1, int maxBins) where T : IPeak, new() { double[] data1 = new double[maxBins]; foreach (var peak in pkl1) { int mzBin = (int)Math.Round(peak.Mz / binWidth); if (IsValidIndex(mzBin, maxBins)) { data1[mzBin] = peak.Intensity; } } return(data1); }
public PeakList <T> Filter(IFilter <T> filter) { PeakList <T> result = NewSubPeakList(); foreach (T peak in this) { if (filter.Accept(peak)) { result.Add(peak); } } return(result); }
public void TestFindEnvelopeDirectly() { var e = new Envelope(444.12, 1, 4).ToList().ConvertAll(m => new Peak() { Mz = m }).ToList(); PeakList <Peak> envolopCharge1 = pl.FindEnvelopeDirectly(e, 0.02, () => new Peak()); Assert.AreEqual(4, envolopCharge1.Count); Assert.AreEqual(0, envolopCharge1[0].Intensity); Assert.AreSame(pl[1], envolopCharge1[1]); Assert.AreSame(pl[3], envolopCharge1[2]); Assert.AreSame(pl[4], envolopCharge1[3]); }
public bool IsSameScan(PeakList <T> another) { if (!this.Experimental.Equals(another.Experimental)) { return(false); } ScanTime firstThis = GetFirstScanTime(); ScanTime firstAnother = another.GetFirstScanTime(); ScanTime lastThis = GetLastScanTime(); ScanTime lastAnother = another.GetLastScanTime(); return(firstThis.Scan != 0 && firstThis.Scan == firstAnother.Scan && lastThis.Scan == lastAnother.Scan); }
public PeakList <Peak> Process(PeakList <Peak> t) { if (t.Count == 0) { return(t); } t.SortByMz(); List <Peak> final = new List <Peak>(); List <Peak> kept = new List <Peak>(); double minMz = 0; double lastMz = t.Last().Mz; int index = 0; while (index < t.Count) { var maxMz = minMz + 100; kept.Clear(); while (index < t.Count) { if (t[index].Mz > maxMz) { break; } kept.Add(t[index]); index++; } if (kept.Count > count) { kept.Sort((m1, m2) => m2.Intensity.CompareTo(m1.Intensity)); kept.RemoveRange(count, kept.Count - count); } final.AddRange(kept); minMz += 100; } t.Clear(); t.AddRange(final); return(t); }
public void Deduct <T>(PeakList <T> pkl) where T : Peak { pkl.SortByMz(); List <T> currPkl = new List <T>(); currPkl.Add(pkl[0]); int end = 1; HashSet <T> deletePkl = new HashSet <T>(); while (true) { while (end < pkl.Count && pkl[end].Mz - currPkl[0].Mz < WINDOW_SIZE) { currPkl.Add(pkl[end]); end++; } if (currPkl.Count <= maxCount) { if (end == pkl.Count) { break; } currPkl.RemoveAt(0); } else { List <T> tmp = new List <T>(currPkl); var lastPeak = currPkl[0]; tmp.Sort((m1, m2) => - m1.Intensity.CompareTo(m2.Intensity)); for (int i = maxCount; i < tmp.Count; i++) { deletePkl.Add(tmp[i]); currPkl.Remove(tmp[i]); } if (currPkl[0] == lastPeak) { currPkl.RemoveAt(0); } } } pkl.RemoveAll(m => deletePkl.Contains(m)); }
public Dictionary <int, PeakList <T> > GetChargeMap() { var result = new Dictionary <int, PeakList <T> >(); foreach (T peak in this) { if (!result.ContainsKey(peak.Charge)) { PeakList <T> pkl = NewSubPeakList(); result.Add(peak.Charge, pkl); } result[peak.Charge].Add(peak); } return(result); }
public void TestFindEnvelop() { PeakList <Peak> envolopCharge1 = pl.FindEnvelope(pl[2], 0.02, false); Assert.AreEqual(3, envolopCharge1.Count); Assert.AreSame(pl[1], envolopCharge1[0]); Assert.AreSame(pl[3], envolopCharge1[1]); Assert.AreSame(pl[4], envolopCharge1[2]); PeakList <Peak> envolopCharge3 = pl.FindEnvelope(pl[8], 0.02, false); Assert.AreEqual(4, envolopCharge3.Count); Assert.AreSame(pl[5], envolopCharge3[0]); Assert.AreSame(pl[6], envolopCharge3[1]); Assert.AreSame(pl[7], envolopCharge3[2]); Assert.AreSame(pl[8], envolopCharge3[3]); }
//Find peak list constains max intensity peak whose mz is equals to assigned peak and charge is zero or equals to assigned peak public static PeakList <T> FindEnvelopeInList(List <PeakList <T> > list, T peak, double mzTolerance) { PeakList <T> result = null; double minMz = peak.Mz - mzTolerance; double maxMz = peak.Mz + mzTolerance; foreach (var pkl in list) { if (pkl[pkl.Count - 1].Mz < minMz) { continue; } if (pkl[0].Mz > maxMz) { break; } PeakList <T> peaks = pkl.FindPeak(peak.Mz, mzTolerance); if (0 == peaks.Count) { continue; } if (0 != pkl[0].Charge && peak.Charge != pkl[0].Charge) { continue; } if (null == result) { result = pkl; continue; } if (result.FindMaxIntensityPeak().Intensity < pkl.FindMaxIntensityPeak().Intensity) { result = pkl; continue; } } return(result); }
public PeakList <T> FindCharge(int charge) { if (0 == charge) { throw new ArgumentException("Charge cannot be zero."); } PeakList <T> result = NewSubPeakList(); foreach (T peak in this) { if (charge == peak.Charge) { result.Add(peak); } } return(result); }
private double GetGap(PeakList <T> pkl, int highestIndex) { double totalDistance = 0.0; double totalWeight = 0.0; for (int i = 0; i < pkl.Count; i++) { if (i == highestIndex) { continue; } var gapCount = Math.Abs(i - highestIndex); var weight = 1 / gapCount; totalDistance += Math.Abs(pkl[i].Mz - pkl[highestIndex].Mz) / gapCount * weight; totalWeight += weight; } return(totalDistance / totalWeight); }
public void SetUp() { pl = new PeakList <Peak>(); pl.Add(new Peak(430.0884, 43875.5, 1)); pl.Add(new Peak(445.1205, 335180.5, 1)); pl.Add(new Peak(446.1185, 51638.0, 1)); pl.Add(new Peak(446.1255, 129918.6, 1)); pl.Add(new Peak(447.1170, 30164.7, 1)); pl.Add(new Peak(491.9578, 442529.3, 3)); pl.Add(new Peak(492.2919, 206717.3, 3)); pl.Add(new Peak(492.6270, 137434.5, 3)); pl.Add(new Peak(492.9613, 26216.6, 3)); pl.Add(new Peak(531.2642, 129351.8, 4)); pl.Add(new Peak(631.2642, 129351.8, 0)); }
public void TestFindEnvelopeInList() { List <PeakList <Peak> > envelopes = pl.GetEnvelopes(20); Peak peak = new Peak(446.1185, 51638.0, 1); double mzTolerance = PrecursorUtils.ppm2mz(peak.Mz, 20); PeakList <Peak> actual = PeakList <Peak> .FindEnvelopeInList(envelopes, peak, mzTolerance); Assert.AreSame(envelopes[1], actual); Peak peak2 = new Peak(631.2642, 129351.8, 1); double mzTolerance2 = PrecursorUtils.ppm2mz(peak2.Mz, 20); PeakList <Peak> actual2 = PeakList <Peak> .FindEnvelopeInList(envelopes, peak2, mzTolerance2); Assert.AreSame(envelopes[4], actual2); Peak missPeak = new Peak(731.2642, 129351.8, 1); double missMzTolerance = PrecursorUtils.ppm2mz(missPeak.Mz, 20); PeakList <Peak> actualMiss = PeakList <Peak> .FindEnvelopeInList(envelopes, missPeak, missMzTolerance); Assert.AreSame(null, actualMiss); }
public PeakList <T> GetRange(double minMz, double maxMz) { if (minMz > maxMz) { throw new ArgumentException(MyConvert.Format("minMz {0} should less than maxMz {1}", minMz, maxMz)); } var result = new PeakList <T>(); foreach (T peak in this) { if (peak.Mz < minMz) { continue; } if (peak.Mz > maxMz) { break; } result.Add(peak); } return(result); }
public PeakList <T> _FindEnvelopeDirectly(List <Peak> profile, double mzTolerance, Func <T> allocator) { var result = new PeakList <T>(); result.scanTimes.AddRange(this.scanTimes); foreach (var curMz in profile) { PeakList <T> find = FindPeak(curMz.Mz, mzTolerance); if (find.Count > 0) { result.Add(find.FindMaxIntensityPeak()); } else { T p = allocator(); p.Mz = curMz.Mz; p.Intensity = 0.0; result.Add(p); } } return(result); }
public int Compare(PeakList <T> x, PeakList <T> y) { if (0 == x.Count) { return(-1); } if (0 == y.Count) { return(1); } if (x[0].Mz < y[0].Mz) { return(-1); } if (x[0].Mz > y[0].Mz) { return(1); } return(0); }
public static PeakList <T> NormalizePeakIntensities <T>(PeakList <T> pkl, double maxPeakMass) where T : IPeak, new() { PeakList <T> result = new PeakList <T>(); result.AssignInforamtion(pkl); foreach (var p in pkl) { result.Add(new T() { Mz = p.Mz, Intensity = p.Intensity, Charge = p.Charge }); } result.RemoveAll(m => m.Mz > maxPeakMass); int maxBins; if (maxPeakMass > 512) { maxBins = (int)Math.Ceiling(maxPeakMass / 1024) * 1024; } else { maxBins = 512; } // Section the original peak array in 10 regions and find the // base peak in each region. Also, square-root the peak intensities const int numberOfRegions = 10; double[] basePeakIntensityByRegion = new double[numberOfRegions]; for (int i = 0; i < basePeakIntensityByRegion.Length; i++) { basePeakIntensityByRegion[i] = 1; } int regionSelector = (int)(maxPeakMass / numberOfRegions); foreach (var peak in result) { peak.Intensity = Math.Sqrt(peak.Intensity); int mzBin = (int)Math.Round(peak.Mz / binWidth); int normalizationIndex = mzBin / regionSelector; if (IsValidIndex(normalizationIndex, numberOfRegions)) { basePeakIntensityByRegion[normalizationIndex] = Math.Max(basePeakIntensityByRegion[normalizationIndex], peak.Intensity); } } // Normalize peaks in each region from 0 to 50. // Use base peak in each region for normalization. foreach (var peak in result) { int mzBin = (int)Math.Round(peak.Mz / binWidth); int normalizationIndex = mzBin / regionSelector; if (IsValidIndex(normalizationIndex, numberOfRegions)) { peak.Intensity = (peak.Intensity / basePeakIntensityByRegion[normalizationIndex]) * 50; } } return(result); }
public PeakList <T> FindEnvelopeDirectly(List <double> profile, int maxProfile, double mzTolerance, Func <T> allocator) { var result = new PeakList <T>(); result.scanTimes.AddRange(this.scanTimes); int start = SearchFirstLarger(profile[0] - mzTolerance); int iPro = 0; int iThis = start; int lenPro = Math.Min(profile.Count, maxProfile); int lenThis = this.Count; if (iThis < lenThis) { var nMzTolerance = -mzTolerance; T curProPeak = default(T); while (true) { double dis = this[iThis].Mz - profile[iPro]; if (dis < nMzTolerance) { iThis++; if (iThis == lenThis) { break; } continue; } if (dis > mzTolerance) { if (curProPeak == null) { T p = allocator(); p.Mz = profile[iPro]; p.Intensity = 0.0; result.Add(p); } else { result.Add(curProPeak); } iPro++; if (iPro == lenPro) { break; } curProPeak = default(T); continue; } if (curProPeak == null || curProPeak.Intensity < this[iThis].Intensity) { curProPeak = this[iThis]; } iThis++; if (iThis == lenThis) { if (curProPeak == null) { T p = allocator(); p.Mz = profile[iPro]; p.Intensity = 0.0; result.Add(p); } else { result.Add(curProPeak); } break; } } } for (int i = result.Count; i < profile.Count; i++) { T p = allocator(); p.Mz = profile[i]; p.Intensity = 0.0; result.Add(p); } return(result); }
public List <PeakList <T> > GetEnvelopes(double ppmTolerance) { var tmp = new PeakList <T>(this); var result = new List <PeakList <T> >(); while (tmp.Count > 0) { double mzTolerance = 2 * PrecursorUtils.ppm2mz(tmp[0].Mz, ppmTolerance); PeakList <T> envelope = tmp.FindEnvelope(tmp[0], mzTolerance, true); result.Add(envelope); foreach (T peak in envelope) { //Remove all peaks around current peak PeakList <T> findPeaks = tmp.FindPeak(peak.Mz, peak.Charge, mzTolerance); foreach (T findPeak in findPeaks) { tmp.Remove(findPeak); } } } result.Sort(new PeakListMzAscendingComparer <T>()); int current = 0; while (current < result.Count - 1) { PeakList <T> currentPkl = result[current]; if (currentPkl[0].Charge > 0) { double expectMz = currentPkl[currentPkl.Count - 1].Mz + ChargeDeconvolution.C_GAP / currentPkl[0].Charge; double mzTolerance = 4 * PrecursorUtils.ppm2mz(currentPkl[0].Mz, ppmTolerance); int next = current + 1; while (next < result.Count) { double gap = result[next][0].Mz - expectMz; if (gap >= 2.0) { break; } if (Math.Abs(gap) > mzTolerance) { next++; continue; } if (result[next][0].Charge != currentPkl[0].Charge) { next++; continue; } currentPkl.AddRange(result[next]); result.RemoveAt(next); } } current++; } return(result); }
public void MergeByMZFirst(PeakList <T> other, double ppmTolerance) { if (0 == other.Count) { return; } if (0 == Count) { AddRange(other); return; } Sort(new PeakMzAscendingComparer <T>()); other.Sort(new PeakMzAscendingComparer <T>()); var result = new List <T>(); int iThisIndex = 0; int iOtherIndex = 0; while (iThisIndex < Count && iOtherIndex < other.Count) { double mzThisTolerance = PrecursorUtils.ppm2mz(this[0].Mz, ppmTolerance); double gap = this[iThisIndex].Mz - other[iOtherIndex].Mz; if (Math.Abs(gap) < mzThisTolerance) { if (this[iThisIndex].Charge == other[iOtherIndex].Charge || 0 == this[iThisIndex].Charge || 0 == other[iOtherIndex].Charge) { double mz = (this[iThisIndex].Mz * this[iThisIndex].Intensity + other[iOtherIndex].Mz * other[iOtherIndex].Intensity) / (this[iThisIndex].Intensity + other[iOtherIndex].Intensity); this[iThisIndex].Mz = mz; this[iThisIndex].Intensity = this[iThisIndex].Intensity + other[iOtherIndex].Intensity; this[iThisIndex].Charge = Math.Max(this[iThisIndex].Charge, other[iOtherIndex].Charge); iOtherIndex++; continue; } } if (gap < 0) { result.Add(this[iThisIndex]); iThisIndex++; } else { result.Add(other[iOtherIndex]); iOtherIndex++; } } while (iThisIndex < Count) { result.Add(this[iThisIndex]); iThisIndex++; } while (iOtherIndex < other.Count) { result.Add(other[iOtherIndex]); iOtherIndex++; } base.Clear(); base.AddRange(result); this.scanTimes.AddRange(other.scanTimes); this.PrecursorIntensity += other.PrecursorIntensity; }