public static void GetXICs(ThermoSpectrum currentSpectrum, int specNumber, double rt)
{
List <LFPeptide> donePeptides = targetPeptides.Where(x => x.LastScan < specNumber).ToList();
foreach (var pep in donePeptides)
{
pep.doneBuildingXIC = true;
}
List <LFPeptide> currPeptides = targetPeptides.Where(x => x.FirstScan <= specNumber && x.LastScan >= specNumber).ToList();
foreach (var pep in currPeptides)
{
List <ThermoMzPeak> outPeaks = new List <ThermoMzPeak>();
if (currentSpectrum.TryGetPeaks(pep.lookupRange, out outPeaks))
{
var matchPeak = GetClosestPeak(outPeaks, pep.UserMZ);
var newRTPeak = new RTPeak(matchPeak, rt);
pep.XICLibrary.Add(newRTPeak);
}
else
{
var newRTPeak = new RTPeak(pep.UserMZ, 0, rt);
pep.XICLibrary.Add(newRTPeak);
}
}
}
public static List <RTPeak> GetRollingAveragePeaks(List <RTPeak> peaks, int period)
{
List <RTPeak> outPeaks = new List <RTPeak>();
if (peaks.Count > 0)
{
for (int i = 0; i < peaks.Count; i++)
{
if (i >= period)
{
double total = 0;
double totalIntensity = 0;
for (int x = i; x > (i - period); x--)
{
total += peaks[x].SN;
totalIntensity += peaks[x].Intensity;
}
double average = total / (double)period;
double averageInt = totalIntensity / (double)period;
RTPeak newPeak = new RTPeak(peaks[i].MZ, averageInt, average, peaks[i - (period / 2)].RT);
outPeaks.Add(newPeak);
}
}
}
return(outPeaks);
}
public static List <RTPeak> GetBoxcarAvgPeaks(List <RTPeak> peaks, int period)
{
var tmpList = new List <RTPeak>();
int peaksToAdd = (period / 2) + 1;
var startPeak = new RTPeak(0, 0, 0);
var stopPeak = new RTPeak(0, 0, 100000);
for (int i = 0; i < peaksToAdd; i++)
{
tmpList.Add(startPeak);
}
foreach (var peak in peaks)
{
tmpList.Add(peak);
}
for (int i = 0; i < peaksToAdd - 1; i++)
{
tmpList.Add(stopPeak);
}
List <RTPeak> outPeaks = new List <RTPeak>();
if (tmpList.Count > 0)
{
for (int i = 0; i < tmpList.Count; i++)
{
if (i >= period)
{
double total = 0;
double totalIntensity = 0;
for (int x = i; x > (i - period); x--)
{
//total += tmpList[x].SN;
totalIntensity += tmpList[x].Intensity;
}
// double average = total / (double)period;
double averageInt = totalIntensity / (double)period;
RTPeak newPeak = new RTPeak(tmpList[i].MZ, averageInt, 0, tmpList[i - (period / 2)].RT);
outPeaks.Add(newPeak);
}
}
}
return(outPeaks);
}
public static List <RTPeak> GetRollingAveragePeaks(LFPeptide targetPeptide, int period, bool isLibrary = true)
{
//add three null points to the beginning and end of the peptide
//you should update this so you can change the smoothing
RTPeak start = new RTPeak(0, 0, 0);
RTPeak end = new RTPeak(0, 0, 100000);
List <RTPeak> copyPeaks = new List <RTPeak>();
if (isLibrary)
{
copyPeaks.Add(start);
copyPeaks.Add(start);
copyPeaks.Add(start);
copyPeaks.Add(start);
foreach (var peak in targetPeptide.XICLibrary)
{
copyPeaks.Add(peak);
}
copyPeaks.Add(end);
copyPeaks.Add(end);
copyPeaks.Add(end);
copyPeaks.Add(end);
copyPeaks = FillInXICGaps(copyPeaks);
return(GetRollingAveragePeaks(copyPeaks, 7));
}
else
{
copyPeaks.Add(start);
copyPeaks.Add(start);
copyPeaks.Add(start);
copyPeaks.Add(start);
foreach (var peak in targetPeptide.XICExperiment)
{
copyPeaks.Add(peak);
}
copyPeaks.Add(end);
copyPeaks.Add(end);
copyPeaks.Add(end);
copyPeaks.Add(end);
copyPeaks = FillInXICGaps(copyPeaks);
return(GetRollingAveragePeaks(copyPeaks, 7));
}
}
private static List <RTPeak> FillInXICGaps(List <RTPeak> peaks)
{
List <RTPeak> returnList = new List <RTPeak>();
returnList.Add(peaks[0]);
for (int i = 1; i < peaks.Count - 1; i++)
{
if (peaks[i - 1].Intensity != 0 && peaks[i].Intensity == 0 && peaks[i + 1].Intensity != 0)
{
//this is a drop out which confuses analysis so fill it in
double intermediateIntensity = peaks[i - 1].Intensity + peaks[i + 1].Intensity;
intermediateIntensity = intermediateIntensity / 2;
double intermediateSN = peaks[i - 1].Sn + peaks[i + 1].Sn;
intermediateSN = intermediateSN / 2;
RTPeak newPeak = new RTPeak(peaks[i].MZ, intermediateIntensity, intermediateSN, peaks[i].RT);
returnList.Add(newPeak);
}
else
{
returnList.Add(peaks[i]);
}
}
return(returnList);
}
public static void GetFWHMWindow(LFPeptide peptide)
{
var apexPeak = peptide.apexPeakLibrary;
var threshold = apexPeak.Intensity * .5;
var startIndex = peptide.SmoothLibrary.BinarySearch(apexPeak);
if (startIndex < 0)
{
startIndex = ~startIndex;
}
RTPeak LeftFWHM = null;
RTPeak RightFWHM = null;
for (int i = startIndex; i < peptide.SmoothLibrary.Count; i++)
{
var currPeak = peptide.SmoothLibrary[i];
if (currPeak.Intensity < threshold)
{
break;
}
RightFWHM = currPeak;
}
for (int i = startIndex; i >= 0; i--)
{
var currPeak = peptide.SmoothLibrary[i];
if (currPeak.Intensity < threshold)
{
break;
}
LeftFWHM = currPeak;
}
peptide.LeftFWHM = LeftFWHM;
peptide.RightFWHM = RightFWHM;
}
public bool Equals(RTPeak obj)
{
return(obj is RTPeak && Equals((RTPeak)obj));
}
public int CompareTo(Object other)
{
RTPeak otherPeak = (RTPeak)other;
return(RT.CompareTo(otherPeak.RT));
}
public int CompareTo(RTPeak other)
{
return(RT.CompareTo(other.RT));
}
public void AddExperimentPeak(RTPeak peak)
{
XICExperiment.Add(peak);
}
public void AddExperimentPeak(MZPeak peak, double RT)
{
var newRTPeak = new RTPeak(peak, RT);
XICExperiment.Add(newRTPeak);
}
public void AddLibraryPeak(RTPeak peak)
{
XICLibrary.Add(peak);
}
public void AddLibraryPeak(MZPeak peak, double RT)
{
var newRTPeak = new RTPeak(peak, RT);
XICLibrary.Add(newRTPeak);
}
public static ChromaPeak GetChromaPeak(RTPeak startPeak, List <RTPeak> XICPeaks)
{
int startIndex = XICPeaks.BinarySearch(startPeak);
if (startIndex < 0)
{
startIndex = ~startIndex;
}
int leftIndex = 0;
int apexIndex = startIndex;
int rightIndex = 0;
double sumLeft = 0;
double sumRight = 0;
for (int i = 1; i <= 5; i++)
{
if ((apexIndex - i) >= 0)
{
sumLeft += XICPeaks[apexIndex - i].Intensity;
}
if ((apexIndex + i) < XICPeaks.Count)
{
sumRight += XICPeaks[apexIndex + i].Intensity;
}
}
if (sumLeft == 0 && sumRight == 0)
{
return(null);
}
var returnPeak = new ChromaPeak();
returnPeak.initialPeak = startPeak;
try
{
if (sumRight > sumLeft) //assume that the max lies to the right
{
bool isAscending = true;
bool isDescending = false;
RTPeak currentMax = XICPeaks[startIndex];
double threshold = currentMax.Intensity * 0.01;
RTPeak currentMinRight = null;
RTPeak currentMinLeft = null;
int currentIndex = 1 + startIndex;
while (isAscending)
{
if (currentIndex < XICPeaks.Count)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity > currentMax.Intensity) //Reset max and threshold, continue on
{
currentMax = currentPeak;
threshold = currentMax.Intensity * 0.01;
currentIndex++;
continue;
}
else //Could be that I was at the apex, or I'm in a dip
{
if (currentPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
//I was at the max, so I want to keep this point
{
//and start looking for the right minimum
isAscending = false;
isDescending = true;
break;
}
else
//could be the start of the descent or some weird dip. Look ahead to the next peaks to find out.
{
int AdditionalCounter = 1;
while (true) //keep in this loop until one of the conditions is satisfied.
{
int aheadIndex = currentIndex + AdditionalCounter;
if ((aheadIndex) < XICPeaks.Count)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
{
isAscending = false;
isDescending = true;
break;
}
if (aheadPeak.Intensity > currentMax.Intensity)
{
currentMax = aheadPeak;
currentIndex += AdditionalCounter;
//currentIndex++;
break;
}
AdditionalCounter++;
}
else
{
isAscending = false;
isDescending = true;
break;
}
}
}
}
}
}
//you have located the max. assume that the peak to right is the local minima
currentIndex++;
if (currentIndex < XICPeaks.Count)
{
currentMinRight = XICPeaks[currentIndex];
}
currentIndex++;
while (isDescending)
{
if (currentIndex < XICPeaks.Count)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinRight.Intensity)
{
currentMinRight = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinRight.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex + AdditionalCounter;
if ((aheadIndex) < XICPeaks.Count)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinRight.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinRight.Intensity || aheadPeak.Intensity == 0)
{
currentMinRight = aheadPeak;
currentIndex += AdditionalCounter;
//currentIndex++;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex++;
}
else
{
isDescending = false;
}
}
//you now have the max, and the right minima. Assume that the peak to the left of the start point is the left minima.
currentIndex = startIndex - 1;
if (currentIndex >= 0)
{
currentMinLeft = XICPeaks[currentIndex];
}
currentIndex--;
isDescending = true;
while (isDescending)
{
if (currentIndex >= 0)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinLeft.Intensity)
{
currentMinLeft = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinLeft.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex - AdditionalCounter;
if ((aheadIndex) >= 0)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinLeft.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinLeft.Intensity || aheadPeak.Intensity == 0)
{
currentMinLeft = aheadPeak;
currentIndex -= AdditionalCounter;
//currentIndex--;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex--;
}
else
{
isDescending = false;
}
}
returnPeak.apexPeak = currentMax;
returnPeak.leftPeak = currentMinLeft;
returnPeak.rightPeak = currentMinRight;
return(returnPeak);
}
else //assume the max lies to the left;
{
bool isAscending = true;
bool isDescending = false;
RTPeak currentMax = XICPeaks[startIndex];
double threshold = currentMax.Intensity * 0.01;
RTPeak currentMinRight = null;
RTPeak currentMinLeft = null;
int currentIndex = startIndex - 1;
while (isAscending)
{
if (currentIndex >= 0)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity > currentMax.Intensity) //Reset max and threshold, continue on
{
currentMax = currentPeak;
threshold = currentMax.Intensity * 0.01;
currentIndex--;
continue;
}
else //Could be that I was at the apex, or I'm in a dip
{
if (currentPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
//I was at the max, so I want to keep this point
{
//and start looking for the right minimum
isAscending = false;
isDescending = true;
break;
}
else
//could be the start of the descent or some weird dip. Look ahead to the next peaks to find out.
{
int AdditionalCounter = 1;
while (true) //keep in this loop until one of the conditions is satisfied.
{
int aheadIndex = currentIndex - AdditionalCounter;
if ((aheadIndex) >= 0)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
{
isAscending = false;
isDescending = true;
break;
}
if (aheadPeak.Intensity > currentMax.Intensity)
{
currentMax = aheadPeak;
currentIndex -= AdditionalCounter;
//currentIndex--;
break;
}
AdditionalCounter++;
}
else
{
isAscending = false;
isDescending = true;
break;
}
}
}
}
}
else
{
isAscending = false;
break;
}
}
currentIndex--;
if (currentIndex >= 0)
{
currentMinLeft = XICPeaks[currentIndex];
}
currentIndex--;
isDescending = true;
while (isDescending)
{
if (currentIndex >= 0)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinLeft.Intensity)
{
currentMinLeft = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinLeft.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex - AdditionalCounter;
if ((aheadIndex) >= 0)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinLeft.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinLeft.Intensity || aheadPeak.Intensity == 0)
{
currentMinLeft = aheadPeak;
currentIndex -= AdditionalCounter;
//currentIndex--;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex--;
}
else
{
isDescending = false;
}
}
isDescending = true;
currentIndex = startIndex + 1;
if (currentIndex < XICPeaks.Count)
{
currentMinRight = XICPeaks[currentIndex];
}
currentIndex++;
while (isDescending)
{
if (currentIndex < XICPeaks.Count)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinRight.Intensity)
{
currentMinRight = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinRight.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex + AdditionalCounter;
if ((aheadIndex) < XICPeaks.Count)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinRight.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinRight.Intensity || aheadPeak.Intensity == 0)
{
currentMinRight = aheadPeak;
currentIndex += AdditionalCounter;
//currentIndex++;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex++;
}
else
{
isDescending = false;
}
}
returnPeak.apexPeak = currentMax;
returnPeak.leftPeak = currentMinLeft;
returnPeak.rightPeak = currentMinRight;
return(returnPeak);
}
}
catch (Exception e)
{
return(null);
}
}
public static void GetApexPeak(LFPeptide targetPeptide, bool isLibrary = true)
{
List <RTPeak> XICPeaks = new List <RTPeak>();
int startIndex = 0;
if (isLibrary)
{
XICPeaks.AddRange(targetPeptide.SmoothLibrary);
startIndex = XICPeaks.BinarySearch(new RTPeak(0, 0, targetPeptide.parentMS1Time));
if (startIndex < 0)
{
startIndex = ~startIndex;
}
}
else
{
XICPeaks.AddRange(targetPeptide.SmoothExperiment);
startIndex = XICPeaks.BinarySearch(targetPeptide.ExperimentLookupPeak);
if (startIndex < 0)
{
startIndex = ~startIndex;
}
}
int leftIndex = 0;
int apexIndex = startIndex;
int rightIndex = 0;
double sumLeft = 0;
double sumRight = 0;
for (int i = 1; i <= 5; i++)
{
if ((apexIndex - i) >= 0)
{
sumLeft += XICPeaks[apexIndex - i].Intensity;
}
if ((apexIndex + i) < XICPeaks.Count)
{
sumRight += XICPeaks[apexIndex + i].Intensity;
}
}
if (sumLeft == 0 && sumRight == 0 && isLibrary)
{
targetPeptide.apexPeakLibrary = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
targetPeptide.rightPeakLibrary = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
targetPeptide.leftPeakLibrary = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
return;
}
if (sumLeft == 0 && sumRight == 0 && !isLibrary)
{
targetPeptide.apexPeakExperiment = new RTPeak(targetPeptide.AdjustedMZ_Experiment, 0, targetPeptide.parentMS1Time);
targetPeptide.rightPeakExperiment = new RTPeak(targetPeptide.AdjustedMZ_Experiment, 0, targetPeptide.parentMS1Time);
targetPeptide.leftPeakExperiment = new RTPeak(targetPeptide.AdjustedMZ_Experiment, 0, targetPeptide.parentMS1Time);
return;
}
try
{
if (sumRight > sumLeft) //assume that the max lies to the right
{
bool isAscending = true;
bool isDescending = false;
RTPeak currentMax = XICPeaks[startIndex];
double threshold = currentMax.Intensity * 0.01;
RTPeak currentMinRight = null;
RTPeak currentMinLeft = null;
int currentIndex = 1 + startIndex;
while (isAscending)
{
if (currentIndex < XICPeaks.Count)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity > currentMax.Intensity) //Reset max and threshold, continue on
{
currentMax = currentPeak;
threshold = currentMax.Intensity * 0.01;
currentIndex++;
continue;
}
else //Could be that I was at the apex, or I'm in a dip
{
if (currentPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
//I was at the max, so I want to keep this point
{
//and start looking for the right minimum
isAscending = false;
isDescending = true;
break;
}
else
//could be the start of the descent or some weird dip. Look ahead to the next peaks to find out.
{
int AdditionalCounter = 1;
while (true) //keep in this loop until one of the conditions is satisfied.
{
int aheadIndex = currentIndex + AdditionalCounter;
if ((aheadIndex) < XICPeaks.Count)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
{
isAscending = false;
isDescending = true;
break;
}
if (aheadPeak.Intensity > currentMax.Intensity)
{
currentMax = aheadPeak;
currentIndex += AdditionalCounter;
//currentIndex++;
break;
}
AdditionalCounter++;
}
else
{
isAscending = false;
isDescending = true;
break;
}
}
}
}
}
}
//you have located the max. assume that the peak to right is the local minima
currentIndex++;
if (currentIndex < XICPeaks.Count)
{
currentMinRight = XICPeaks[currentIndex];
}
currentIndex++;
while (isDescending)
{
if (currentIndex < XICPeaks.Count)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinRight.Intensity)
{
currentMinRight = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinRight.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex + AdditionalCounter;
if ((aheadIndex) < XICPeaks.Count)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinRight.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinRight.Intensity || aheadPeak.Intensity == 0)
{
currentMinRight = aheadPeak;
currentIndex += AdditionalCounter;
//currentIndex++;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
}
else
{
isDescending = false;
break;
}
currentIndex++;
}
//you now have the max, and the right minima. Assume that the peak to the left of the start point is the left minima.
currentIndex = startIndex - 1;
if (currentIndex >= 0)
{
currentMinLeft = XICPeaks[currentIndex];
}
currentIndex--;
isDescending = true;
while (isDescending)
{
if (currentIndex >= 0)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinLeft.Intensity)
{
currentMinLeft = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinLeft.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex - AdditionalCounter;
if ((aheadIndex) >= 0)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinLeft.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinLeft.Intensity || aheadPeak.Intensity == 0)
{
currentMinLeft = aheadPeak;
currentIndex -= AdditionalCounter;
//currentIndex--;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex--;
}
else
{
isDescending = false;
}
}
if (isLibrary)
{
targetPeptide.apexPeakLibrary = currentMax;
targetPeptide.leftPeakLibrary = currentMinLeft;
targetPeptide.rightPeakLibrary = currentMinRight;
}
else
{
targetPeptide.apexPeakExperiment = currentMax;
targetPeptide.leftPeakExperiment = currentMinLeft;
targetPeptide.rightPeakExperiment = currentMinRight;
}
}
else //assume the max lies to the left;
{
bool isAscending = true;
bool isDescending = false;
RTPeak currentMax = XICPeaks[startIndex];
double threshold = currentMax.Intensity * 0.01;
RTPeak currentMinRight = null;
RTPeak currentMinLeft = null;
int currentIndex = startIndex - 1;
while (isAscending)
{
if (currentIndex >= 0)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity > currentMax.Intensity) //Reset max and threshold, continue on
{
currentMax = currentPeak;
threshold = currentMax.Intensity * 0.01;
currentIndex--;
continue;
}
else //Could be that I was at the apex, or I'm in a dip
{
if (currentPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
//I was at the max, so I want to keep this point
{
//and start looking for the right minimum
isAscending = false;
isDescending = true;
break;
}
else
//could be the start of the descent or some weird dip. Look ahead to the next peaks to find out.
{
int AdditionalCounter = 1;
while (true) //keep in this loop until one of the conditions is satisfied.
{
int aheadIndex = currentIndex - AdditionalCounter;
if ((aheadIndex) >= 0)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity < (currentMax.Intensity * (1.0 / 1.8)))
{
isAscending = false;
isDescending = true;
break;
}
if (aheadPeak.Intensity > currentMax.Intensity)
{
currentMax = aheadPeak;
currentIndex -= AdditionalCounter;
//currentIndex--;
break;
}
AdditionalCounter++;
}
else
{
isAscending = false;
isDescending = true;
break;
}
}
}
}
}
}
currentIndex--;
if (currentIndex >= 0)
{
currentMinLeft = XICPeaks[currentIndex];
}
currentIndex--;
isDescending = true;
while (isDescending)
{
if (currentIndex >= 0)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinLeft.Intensity)
{
currentMinLeft = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinLeft.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex - AdditionalCounter;
if ((aheadIndex) >= 0)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinLeft.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinLeft.Intensity || aheadPeak.Intensity == 0)
{
currentMinLeft = aheadPeak;
currentIndex -= AdditionalCounter;
//currentIndex--;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex--;
}
else
{
isDescending = false;
}
}
isDescending = true;
currentIndex = startIndex + 1;
if (currentIndex < XICPeaks.Count)
{
currentMinRight = XICPeaks[currentIndex];
}
currentIndex++;
while (isDescending)
{
if (currentIndex < XICPeaks.Count)
{
var currentPeak = XICPeaks[currentIndex];
if (currentPeak.Intensity <= currentMinRight.Intensity)
{
currentMinRight = currentPeak;
if (currentPeak.Intensity < threshold)
{
isDescending = false;
break;
}
}
if (currentPeak.Intensity > currentMinRight.Intensity)
//could be the local min or some weird dip
{
int AdditionalCounter = 1;
while (true)
{
int aheadIndex = currentIndex + AdditionalCounter;
if ((aheadIndex) < XICPeaks.Count)
{
var aheadPeak = XICPeaks[aheadIndex];
if (aheadPeak.Intensity > (1.8 * currentMinRight.Intensity))
//There is a new peak coming up. You have found the local min. Break out.
{
isDescending = false;
break;
}
if (aheadPeak.Intensity < currentMinRight.Intensity || aheadPeak.Intensity == 0)
{
currentMinRight = aheadPeak;
currentIndex += AdditionalCounter;
//currentIndex++;
break;
}
AdditionalCounter++;
}
else
{
isDescending = false;
break;
}
}
}
currentIndex++;
}
else
{
isDescending = false;
}
}
if (isLibrary)
{
targetPeptide.apexPeakLibrary = currentMax;
targetPeptide.leftPeakLibrary = currentMinLeft;
targetPeptide.rightPeakLibrary = currentMinRight;
}
else
{
targetPeptide.apexPeakExperiment = currentMax;
targetPeptide.leftPeakExperiment = currentMinLeft;
targetPeptide.rightPeakExperiment = currentMinRight;
}
}
}
catch (Exception e)
{
if (isLibrary)
{
targetPeptide.apexPeakLibrary = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
targetPeptide.leftPeakLibrary = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
targetPeptide.rightPeakLibrary = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
}
else
{
targetPeptide.apexPeakExperiment = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
targetPeptide.leftPeakExperiment = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
targetPeptide.rightPeakExperiment = new RTPeak(targetPeptide.AdjustedMZ_Library, 0, targetPeptide.parentMS1Time);
}
return;
}
}
