public bool GetChromatogram(ChromKey chromKey, out TimeIntensities timeIntensities)
{
int keyIndex = -1;
if (_chromKeyIndiceses != null)
{
var tolerance = (float)ChromTaskList.SrmDocument.Settings.TransitionSettings.Instrument.MzMatchTolerance;
keyIndex = _chromKeyIndiceses.IndexOf(entry => EqualsTolerant(chromKey, entry.Key, tolerance));
}
if (keyIndex == -1 || _chromKeyIndiceses == null) // Keep ReSharper from complaining
{
timeIntensities = null;
return(false);
}
ChromKeyIndices chromKeyIndices = _chromKeyIndiceses[keyIndex];
var chromGroupInfo = _chromatogramCache.LoadChromatogramInfo(chromKeyIndices.GroupIndex);
chromGroupInfo.ReadChromatogram(_chromatogramCache);
var tranInfo = chromGroupInfo.GetTransitionInfo(chromKeyIndices.TranIndex);
if (tranInfo.TimeIntensities == null || tranInfo.TimeIntensities.NumPoints == 0)
{
// Chorus returns zero length chromatogram to indicate that no spectra matched
// the precursor filter.
timeIntensities = null;
return(false);
}
timeIntensities = CoalesceIntensities(tranInfo.TimeIntensities);
return(true);
}
public void TestMergeTimesAndAddIntensities()
{
TimeIntensities oddTimes = new TimeIntensities(new [] { 1f, 3, 5, 7, 9 }, new [] { 3f, 6, 9, 12, 15 }, null, null);
TimeIntensities evenTimes = new TimeIntensities(new [] { 2f, 4, 6, 8 }, new[] { 10f, 9, 8, 7 }, null, null);
var expectedMergedTimes = ImmutableList.ValueOf(new[] { 1f, 2, 3, 4, 5, 6, 7, 8, 9 });
var mergedAndAdded = oddTimes.MergeTimesAndAddIntensities(evenTimes);
var mergedAndAdded2 = evenTimes.MergeTimesAndAddIntensities(oddTimes);
Assert.AreEqual(expectedMergedTimes, mergedAndAdded.Times);
Assert.AreEqual(expectedMergedTimes, mergedAndAdded2.Times);
Assert.AreEqual(mergedAndAdded.Intensities, mergedAndAdded2.Intensities);
var oddInterpolated = oddTimes.Interpolate(expectedMergedTimes, false);
var evenInterpolated = evenTimes.Interpolate(expectedMergedTimes, false);
var sumOfInterpolatedIntensities = oddInterpolated.Intensities
.Zip(evenInterpolated.Intensities, (f1, f2) => f1 + f2)
.ToArray();
CollectionAssert.AreEqual(sumOfInterpolatedIntensities, mergedAndAdded.Intensities.ToArray());
var addedToOdds = oddTimes.AddIntensities(evenTimes);
Assert.AreEqual(oddTimes.Times, addedToOdds.Times);
var addedToEvens = evenTimes.AddIntensities(oddTimes);
Assert.AreEqual(evenTimes.Times, addedToEvens.Times);
}
public static void MakeChromatogramInfo(SignedMz precursorMz, LibraryChromGroup chromGroup, LibraryChromGroup.ChromData chromData, out ChromatogramInfo chromatogramInfo, out TransitionChromInfo transitionChromInfo)
{
var timeIntensities = new TimeIntensities(chromGroup.Times, chromData.Intensities, null, null);
var crawPeakFinder = Crawdads.NewCrawdadPeakFinder();
crawPeakFinder.SetChromatogram(chromGroup.Times, chromData.Intensities);
var crawdadPeak =
crawPeakFinder.GetPeak(
FindNearestIndex(chromGroup.Times, (float)chromGroup.StartTime),
FindNearestIndex(chromGroup.Times, (float)chromGroup.EndTime));
var chromPeak = new ChromPeak(crawPeakFinder, crawdadPeak, 0, timeIntensities, null);
transitionChromInfo = new TransitionChromInfo(null, 0, chromPeak,
IonMobilityFilter.EMPTY, // CONSIDER(bspratt) IMS in chromatogram libraries?
new float?[0], Annotations.EMPTY,
UserSet.FALSE);
var peaks = new[] { chromPeak };
var header = new ChromGroupHeaderInfo(precursorMz,
0, // file index
1, // numTransitions
0, // startTransitionIndex
peaks.Length, // numPeaks
0, // startPeakIndex
0, // startscoreindex
0, // maxPeakIndex
chromGroup.Times.Length, // numPoints
0, // compressedSize
0, // uncompressedsize
0, //location
0, -1, -1, null, null, null, eIonMobilityUnits.none); // CONSIDER(bspratt) IMS in chromatogram libraries?
var driftTimeFilter = IonMobilityFilter.EMPTY; // CONSIDER(bspratt) IMS in chromatogram libraries?
var groupInfo = new ChromatogramGroupInfo(header,
new Dictionary <Type, int>(),
new byte[0],
new ChromCachedFile[0],
new[] { new ChromTransition(chromData.Mz, 0, (float)(driftTimeFilter.IonMobility.Mobility ?? 0), (float)(driftTimeFilter.IonMobilityExtractionWindowWidth ?? 0), ChromSource.unknown), },
peaks,
null)
{
TimeIntensitiesGroup = TimeIntensitiesGroup.Singleton(timeIntensities)
};
chromatogramInfo = new ChromatogramInfo(groupInfo, 0);
}
public void TestChromPeakIntegration()
{
var times = Enumerable.Range(0, 12).Select(i => (float)i).ToArray();
var timeIntensities = new TimeIntensities(times, times.Select(t => 36 - (t - 6) * (t - 6)), null, null);
var chromPeak = new ChromPeak(timeIntensities, 1, 11, 0);
Assert.AreEqual(36f, chromPeak.Height);
Assert.AreEqual(11, timeIntensities.Intensities[1]);
Assert.AreEqual(20, timeIntensities.Intensities[2]);
var fwhmStart = (7 * 2 + 2 * 1) / 9.0;
Assert.AreEqual(20, timeIntensities.Intensities[10]);
Assert.AreEqual(11, timeIntensities.Intensities[11]);
var fwhmEnd = (7 * 10 + 2 * 11) / 9.0;
Assert.AreEqual(fwhmEnd - fwhmStart, chromPeak.Fwhm, .00001);
Assert.AreEqual(false, chromPeak.IsFwhmDegenerate);
var chromPeak2 = new ChromPeak(timeIntensities, 2, 10, 0);
Assert.AreEqual(8, chromPeak2.Fwhm);
Assert.AreEqual(true, chromPeak2.IsFwhmDegenerate);
}
public bool GetChromatogram(ChromKey chromKey, out TimeIntensities timeIntensities)
{
ChromatogramGeneratorTask task;
if (!_chromKeys.TryGetValue(chromKey, out task))
{
timeIntensities = null;
return(false);
}
lock (LockObj)
{
StartTask(task);
while (!task.IsFinished())
{
Monitor.Wait(LockObj, CANCEL_CHECK_MILLIS);
CheckCancelled();
}
if (null != _exception)
{
throw new ChorusServerException(_exception.Message, _exception);
}
}
return(task.GetChromatogram(chromKey, out timeIntensities));
}
public Data(TimeIntensities timeIntensities, Lazy <MsDataFileScanIds> scanIds)
{
_timeIntensities = timeIntensities;
_scanIds = scanIds;
}
public Data(TimeIntensities timeIntensities)
{
_timeIntensities = timeIntensities;
}
/// <summary>
/// If the chromatogram contains duplicate times, combine those duplicate times by summing the intensities
/// and appropriately averaging the mass errors.
/// TODO(nicksh): Remove this once Chorus changes to not have these duplicates.
/// </summary>
private TimeIntensities CoalesceIntensities(TimeIntensities timeIntensities)
{
IList <float> times = timeIntensities.Times;
IList <float> intensities = timeIntensities.Intensities;
IList <int> scanIds = timeIntensities.ScanIds;
IList <float> massErrors = timeIntensities.MassErrors;
List <float> newTimes = new List <float>();
List <int> newScanIds = new List <int>();
List <float> newIntensities = new List <float>();
List <float> newMassErrors = new List <float>();
float? curTime = null;
int curScanId = 0;
double curIntensity = 0;
double curMassError = 0;
bool anyCoalescing = false;
for (int i = 0; i < times.Count; i++)
{
if (times[i] != curTime)
{
if (curTime.HasValue)
{
newTimes.Add(curTime.Value);
newScanIds.Add(curScanId);
newIntensities.Add((float)curIntensity);
newMassErrors.Add((float)curMassError);
}
curTime = times[i];
curIntensity = intensities[i];
if (null != scanIds)
{
curScanId = scanIds[i];
}
if (null != massErrors)
{
curMassError = massErrors[i];
}
}
else
{
anyCoalescing = true;
var newIntensity = curIntensity + intensities[i];
if (newIntensity > 0)
{
if (null != massErrors)
{
curMassError = (curMassError * curIntensity + massErrors[i] * intensities[i]) / newIntensity;
}
curIntensity = newIntensity;
}
else
{
curIntensity = intensities[i];
if (null != massErrors)
{
curMassError = massErrors[i];
}
}
}
}
if (curTime.HasValue)
{
newTimes.Add(curTime.Value);
newScanIds.Add(curScanId);
newIntensities.Add((float)curIntensity);
newMassErrors.Add((float)curMassError);
}
if (!anyCoalescing)
{
return(timeIntensities);
}
return(new TimeIntensities(newTimes, newIntensities, massErrors == null ? null : newMassErrors, scanIds == null ? null : newScanIds));
}
