internal void ProcessChromGroup(MinimizedChromGroup minimizedChromGroup)
{
var headerInfo = minimizedChromGroup.ChromGroupHeaderInfo;
int replicateIndex = _fileIndexToReplicateIndex[headerInfo.FileIndex];
long originalFileSize = GetFileSize(headerInfo);
double minimizedFileSize;
if (replicateIndex < 0)
{
minimizedFileSize = 0;
}
else
{
minimizedFileSize = originalFileSize;
var header = minimizedChromGroup.ChromGroupHeaderInfo;
if (header.StartTime.HasValue && header.EndTime.HasValue && minimizedChromGroup.OptimizedEndTime.HasValue && minimizedChromGroup.OptimizedStartTime.HasValue)
{
double oldLength = header.EndTime.Value - header.StartTime.Value;
double newLength = minimizedChromGroup.OptimizedEndTime.Value -
minimizedChromGroup.OptimizedStartTime.Value;
if (oldLength > 0 && newLength > 0)
{
minimizedFileSize *= newLength / oldLength;
}
}
minimizedFileSize = minimizedFileSize * minimizedChromGroup.RetainedTransitionIndexes.Count /
minimizedChromGroup.ChromGroupHeaderInfo.NumTransitions;
}
_replicates[replicateIndex].MinimizedFileSize += minimizedFileSize;
_replicates[replicateIndex].ProcessedFileSize += originalFileSize;
}
public void Write(MinimizedChromGroup minimizedChromGroup)
{
// Then one thread at a time for updating statistics and writing
lock (StatisticsCollector)
{
UpdateStatistics(minimizedChromGroup);
if (Writer != null)
{
Writer.WriteChromGroup(ChromGroupInfo, minimizedChromGroup);
}
}
}
internal void ProcessChromGroup(MinimizedChromGroup minimizedChromGroup)
{
Assume.IsTrue(Equals(minimizedChromGroup.ChromGroupHeaderInfo, ChromCacheMinimizer.ChromGroupHeaderInfos[_processedGroupCount]));
var headerInfo = minimizedChromGroup.ChromGroupHeaderInfo;
int replicateIndex = _fileIndexToReplicateIndex[headerInfo.FileIndex];
long originalFileSize = GetFileSize(headerInfo);
double minimizedFileSize;
if (replicateIndex < 0)
{
minimizedFileSize = 0;
}
else
{
minimizedFileSize = originalFileSize;
minimizedFileSize *= (minimizedChromGroup.OptimizedLastScan - minimizedChromGroup.OptimizedFirstScan + 1.0)
/ minimizedChromGroup.ChromGroupHeaderInfo.NumPoints;
minimizedFileSize = minimizedFileSize * minimizedChromGroup.RetainedTransitionIndexes.Count /
minimizedChromGroup.ChromGroupHeaderInfo.NumTransitions;
}
_replicates[replicateIndex].MinimizedFileSize += minimizedFileSize;
_replicates[replicateIndex].ProcessedFileSize += originalFileSize;
_processedGroupCount++;
}
public void WriteChromGroup(ChromatogramGroupInfo originalChromGroup, MinimizedChromGroup minimizedChromGroup)
{
if (minimizedChromGroup.RetainedTransitionIndexes.Count == 0)
{
return;
}
var originalHeader = originalChromGroup.Header;
int fileIndex = originalHeader.FileIndex;
int startTransitionIndex = _transitions.Count;
int startPeakIndex = _peakCount;
int startScoreIndex = _scoreCount;
for (int iPeak = 0; iPeak < originalHeader.NumPeaks; iPeak++)
{
int iScores = originalHeader.StartScoreIndex + iPeak*_scoreTypes.Count;
var scores = _originalCache.GetCachedScores(iScores).ToArray();
PrimitiveArrays.Write(_outputStreamScores, scores);
_scoreCount += scores.Length;
}
int numPoints = minimizedChromGroup.OptimizedLastScan - minimizedChromGroup.OptimizedFirstScan + 1;
var retainedPeakIndexes = new HashSet<int>();
if (minimizedChromGroup.OptimizedStartTime.HasValue && minimizedChromGroup.OptimizedEndTime.HasValue)
{
for (int iPeak = 0; iPeak < originalHeader.NumPeaks; iPeak++)
{
bool outsideRange = false;
for (var transitionIndex = 0; transitionIndex < originalHeader.NumTransitions; transitionIndex++)
{
if (!minimizedChromGroup.RetainedTransitionIndexes.Contains(transitionIndex))
continue;
var peak = _originalCache.GetPeak(originalHeader.StartPeakIndex +
transitionIndex*originalHeader.NumPeaks + iPeak);
if (peak.StartTime < minimizedChromGroup.OptimizedStartTime.Value ||
peak.EndTime > minimizedChromGroup.OptimizedEndTime.Value)
{
outsideRange = true;
break;
}
}
if (!outsideRange)
{
retainedPeakIndexes.Add(iPeak);
}
}
}
else
{
retainedPeakIndexes.UnionWith(Enumerable.Range(0, originalHeader.NumPeaks));
}
int numPeaks = retainedPeakIndexes.Count;
int maxPeakIndex;
if (retainedPeakIndexes.Contains(originalHeader.MaxPeakIndex))
{
maxPeakIndex = retainedPeakIndexes.Count(index => index < originalHeader.MaxPeakIndex);
}
else
{
maxPeakIndex = -1;
}
long location = _outputStream.Position;
float[] times = originalChromGroup.Times.Skip(minimizedChromGroup.OptimizedFirstScan).Take(numPoints).ToArray();
List<float[]> intensities = new List<float[]>();
List<short[]> massError10Xs = originalChromGroup.MassError10XArray != null
? new List<short[]>()
: null;
int[][] scanIndexes = null;
if (originalChromGroup.ScanIndexes != null)
{
scanIndexes = new int[originalChromGroup.ScanIndexes.Length][];
for (int i = 0; i < scanIndexes.Length; i++)
{
if (originalChromGroup.ScanIndexes[i] != null)
{
scanIndexes[i] =
originalChromGroup.ScanIndexes[i].Skip(minimizedChromGroup.OptimizedFirstScan)
.Take(numPoints)
.ToArray();
}
}
}
foreach (var originalIndex in minimizedChromGroup.RetainedTransitionIndexes)
{
_transitions.Add(_originalCache.GetTransition(originalIndex + originalHeader.StartTransitionIndex));
for (int originalPeakIndex = 0; originalPeakIndex < originalHeader.NumPeaks; originalPeakIndex++)
{
if (!retainedPeakIndexes.Contains(originalPeakIndex))
continue;
var originalPeak = _originalCache.GetPeak(originalHeader.StartPeakIndex +
originalIndex*originalHeader.NumPeaks +
originalPeakIndex);
_peakCount++;
ChromPeak.WriteArray(_outputStreamPeaks.SafeFileHandle, new[] {originalPeak});
}
intensities.Add(originalChromGroup.IntensityArray[originalIndex]
.Skip(minimizedChromGroup.OptimizedFirstScan)
.Take(numPoints).ToArray());
if (massError10Xs != null)
{
massError10Xs.Add(originalChromGroup.MassError10XArray[originalIndex]
.Skip(minimizedChromGroup.OptimizedFirstScan)
.Take(numPoints).ToArray());
}
}
var massError10XArray = massError10Xs != null ? massError10Xs.ToArray() : null;
byte[] points = ChromatogramCache.TimeIntensitiesToBytes(times, intensities.ToArray(), massError10XArray, scanIndexes);
// Compress the data (can be huge for AB data with lots of zeros)
byte[] pointsCompressed = points.Compress(3);
int lenCompressed = pointsCompressed.Length;
_outputStream.Write(pointsCompressed, 0, lenCompressed);
var header = new ChromGroupHeaderInfo5(originalHeader.Precursor,
originalHeader.TextIdIndex,
originalHeader.TextIdLen,
fileIndex,
_transitions.Count - startTransitionIndex,
startTransitionIndex,
numPeaks,
startPeakIndex,
startScoreIndex,
maxPeakIndex,
numPoints,
pointsCompressed.Length,
location,
originalHeader.Flags,
originalHeader.StatusId,
originalHeader.StatusRank);
_chromGroupHeaderInfos.Add(header);
}
internal void ProcessChromGroup(MinimizedChromGroup minimizedChromGroup)
{
Assume.IsTrue(Equals(minimizedChromGroup.ChromGroupHeaderInfo, ChromCacheMinimizer.ChromGroupHeaderInfos[_processedGroupCount]));
var headerInfo = minimizedChromGroup.ChromGroupHeaderInfo;
int replicateIndex = _fileIndexToReplicateIndex[headerInfo.FileIndex];
long originalFileSize = GetFileSize(headerInfo);
double minimizedFileSize;
if (replicateIndex < 0)
{
minimizedFileSize = 0;
}
else
{
minimizedFileSize = originalFileSize;
minimizedFileSize *= (minimizedChromGroup.OptimizedLastScan - minimizedChromGroup.OptimizedFirstScan + 1.0)
/ minimizedChromGroup.ChromGroupHeaderInfo.NumPoints;
minimizedFileSize = minimizedFileSize * minimizedChromGroup.RetainedTransitionIndexes.Count /
minimizedChromGroup.ChromGroupHeaderInfo.NumTransitions;
}
_replicates[replicateIndex].MinimizedFileSize += minimizedFileSize;
_replicates[replicateIndex].ProcessedFileSize += originalFileSize;
_processedGroupCount++;
}
/// <summary>
/// Decides what information from a ChromatogramGroupInfo should be thrown away.
/// ChromatogramGroupInfo's can have the the retention time range shortened, and certain
/// transitions discarded.
/// </summary>
private MinimizedChromGroup MinimizeChromGroup(Settings settings, ChromatogramGroupInfo chromatogramGroupInfo, IList<TransitionGroupDocNode> transitionGroups)
{
var fileIndexes = new List<int>();
for (int fileIndex = 0; fileIndex < Document.Settings.MeasuredResults.Chromatograms.Count; fileIndex++)
{
var chromatogramSet = Document.Settings.MeasuredResults.Chromatograms[fileIndex];
if (chromatogramSet.MSDataFilePaths.Any(path=>Equals(path, chromatogramGroupInfo.FilePath)))
{
fileIndexes.Add(fileIndex);
}
}
var chromatograms = chromatogramGroupInfo.TransitionPointSets.ToArray();
Assume.IsTrue(Equals(chromatogramGroupInfo.NumTransitions, chromatograms.Length));
var keptTransitionIndexes = new List<int>();
double minRetentionTime = Double.MaxValue;
double maxRetentionTime = -Double.MaxValue;
for (int i = 0; i < chromatograms.Length; i++)
{
var chromatogram = chromatograms[i];
var matchingTransitions = new List<TransitionDocNode>();
foreach (var transitionDocNode in transitionGroups.SelectMany(tg => tg.Transitions))
{
if (0!=ChromKey.CompareTolerant((float) chromatogram.ProductMz, (float) transitionDocNode.Mz, _tolerance))
{
continue;
}
matchingTransitions.Add(transitionDocNode);
foreach (var fileIndex in fileIndexes)
{
var chromatogramSet = transitionDocNode.Results[fileIndex];
if (chromatogramSet == null)
{
continue;
}
foreach (var transitionChromInfo in chromatogramSet)
{
if (transitionChromInfo.IsEmpty)
{
continue;
}
minRetentionTime = Math.Min(minRetentionTime, transitionChromInfo.StartRetentionTime);
maxRetentionTime = Math.Max(maxRetentionTime, transitionChromInfo.EndRetentionTime);
}
}
}
bool kept = !settings.DiscardUnmatchedChromatograms
|| matchingTransitions.Count > 0;
if (kept)
{
keptTransitionIndexes.Add(i);
}
}
var result = new MinimizedChromGroup(chromatogramGroupInfo.Header)
{
RetainedTransitionIndexes = keptTransitionIndexes,
};
if (settings.NoiseTimeRange.HasValue && minRetentionTime < maxRetentionTime)
{
if (null == chromatogramGroupInfo.Times)
{
// Chromatogram was unreadable.
result.RetainedTransitionIndexes.Clear();
}
else
{
result.SetStartEndTime(chromatogramGroupInfo.Times, (float)(minRetentionTime - settings.NoiseTimeRange), (float)(maxRetentionTime + settings.NoiseTimeRange));
}
}
return result;
}
/// <summary>
/// Collects statistics on how much space savings minimizing will achieve, and (if outStream
/// is not null) writes out the minimized cache file.
/// </summary>
public void Minimize(Settings settings, ProgressCallback progressCallback, Stream outStream,
FileStream outStreamScans = null, FileStream outStreamPeaks = null, FileStream outStreamScores = null)
{
var writer = outStream == null ? null : new Writer(ChromatogramCache, outStream, outStreamScans, outStreamPeaks, outStreamScores);
var statisticsCollector = new MinStatisticsCollector(this);
bool readChromatograms = settings.NoiseTimeRange.HasValue || writer != null;
var chromGroupHeaderToIndex =
ChromGroupHeaderInfos
.Select((cghi, index) => new KeyValuePair <ChromGroupHeaderInfo5, int>(cghi, index))
.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
var chromGroups = new ChromatogramGroupInfo[ChromGroupHeaderInfos.Count];
var transitionGroups = new List <TransitionGroupDocNode> [ChromGroupHeaderInfos.Count];
foreach (var nodePep in Document.Molecules)
{
foreach (var nodeGroup in nodePep.TransitionGroups)
{
ChromatogramGroupInfo[] groupInfos;
ChromatogramCache.TryLoadChromatogramInfo(nodePep, nodeGroup, _tolerance, out groupInfos);
foreach (var chromGroupInfo in groupInfos)
{
int headerIndex = chromGroupHeaderToIndex[chromGroupInfo.Header];
if (chromGroups[headerIndex] == null)
{
chromGroups[headerIndex] = chromGroupInfo;
transitionGroups[headerIndex] = new List <TransitionGroupDocNode>();
}
transitionGroups[headerIndex].Add(nodeGroup);
}
}
}
for (int iHeader = 0; iHeader < ChromGroupHeaderInfos.Count; iHeader++)
{
var chromGroupInfo = chromGroups[iHeader];
IList <TransitionGroupDocNode> transitionGroupDocNodes;
if (chromGroupInfo == null)
{
chromGroupInfo = ChromatogramCache.LoadChromatogramInfo(ChromGroupHeaderInfos[iHeader]);
transitionGroupDocNodes = new TransitionGroupDocNode[0];
}
else
{
transitionGroupDocNodes = transitionGroups[iHeader];
}
if (readChromatograms)
{
try
{
chromGroupInfo.ReadChromatogram(ChromatogramCache);
}
catch (Exception exception)
{
Trace.TraceWarning("Unable to read chromatogram {0}", exception); // Not L10N
}
}
MinimizedChromGroup minimizedChromGroup = MinimizeChromGroup(settings,
chromGroupInfo, transitionGroupDocNodes);
statisticsCollector.ProcessChromGroup(minimizedChromGroup);
if (progressCallback != null)
{
progressCallback.Invoke(statisticsCollector.GetStatistics());
}
if (writer != null)
{
writer.WriteChromGroup(chromGroupInfo, minimizedChromGroup);
}
// Null out the ChromGroup in our array so it can be garbage collected.
chromGroups[iHeader] = null;
}
if (progressCallback != null)
{
progressCallback.Invoke(statisticsCollector.GetStatistics());
}
if (writer != null)
{
writer.WriteEndOfFile();
}
}
public void WriteChromGroup(ChromatogramGroupInfo originalChromGroup, MinimizedChromGroup minimizedChromGroup)
{
if (minimizedChromGroup.RetainedTransitionIndexes.Count == 0)
{
return;
}
var originalHeader = originalChromGroup.Header;
int fileIndex = originalHeader.FileIndex;
int startTransitionIndex = _transitions.Count;
int startPeakIndex = _peakCount;
int startScoreIndex = _scoreCount;
for (int iPeak = 0; iPeak < originalHeader.NumPeaks; iPeak++)
{
int iScores = originalHeader.StartScoreIndex + iPeak * _scoreTypes.Count;
var scores = _originalCache.GetCachedScores(iScores).ToArray();
PrimitiveArrays.Write(_outputStreamScores, scores);
_scoreCount += scores.Length;
}
int numPoints = minimizedChromGroup.OptimizedLastScan - minimizedChromGroup.OptimizedFirstScan + 1;
var retainedPeakIndexes = new HashSet <int>();
if (minimizedChromGroup.OptimizedStartTime.HasValue && minimizedChromGroup.OptimizedEndTime.HasValue)
{
for (int iPeak = 0; iPeak < originalHeader.NumPeaks; iPeak++)
{
bool outsideRange = false;
for (var transitionIndex = 0; transitionIndex < originalHeader.NumTransitions; transitionIndex++)
{
if (!minimizedChromGroup.RetainedTransitionIndexes.Contains(transitionIndex))
{
continue;
}
var peak = _originalCache.GetPeak(originalHeader.StartPeakIndex +
transitionIndex * originalHeader.NumPeaks + iPeak);
if (peak.StartTime < minimizedChromGroup.OptimizedStartTime.Value ||
peak.EndTime > minimizedChromGroup.OptimizedEndTime.Value)
{
outsideRange = true;
break;
}
}
if (!outsideRange)
{
retainedPeakIndexes.Add(iPeak);
}
}
}
else
{
retainedPeakIndexes.UnionWith(Enumerable.Range(0, originalHeader.NumPeaks));
}
int numPeaks = retainedPeakIndexes.Count;
int maxPeakIndex;
if (retainedPeakIndexes.Contains(originalHeader.MaxPeakIndex))
{
maxPeakIndex = retainedPeakIndexes.Count(index => index < originalHeader.MaxPeakIndex);
}
else
{
maxPeakIndex = -1;
}
long location = _outputStream.Position;
float[] times = originalChromGroup.Times.Skip(minimizedChromGroup.OptimizedFirstScan).Take(numPoints).ToArray();
List <float[]> intensities = new List <float[]>();
List <short[]> massError10Xs = originalChromGroup.MassError10XArray != null
? new List <short[]>()
: null;
int[][] scanIndexes = null;
if (originalChromGroup.ScanIndexes != null)
{
scanIndexes = new int[originalChromGroup.ScanIndexes.Length][];
for (int i = 0; i < scanIndexes.Length; i++)
{
if (originalChromGroup.ScanIndexes[i] != null)
{
scanIndexes[i] =
originalChromGroup.ScanIndexes[i].Skip(minimizedChromGroup.OptimizedFirstScan)
.Take(numPoints)
.ToArray();
}
}
}
foreach (var originalIndex in minimizedChromGroup.RetainedTransitionIndexes)
{
_transitions.Add(_originalCache.GetTransition(originalIndex + originalHeader.StartTransitionIndex));
for (int originalPeakIndex = 0; originalPeakIndex < originalHeader.NumPeaks; originalPeakIndex++)
{
if (!retainedPeakIndexes.Contains(originalPeakIndex))
{
continue;
}
var originalPeak = _originalCache.GetPeak(originalHeader.StartPeakIndex +
originalIndex * originalHeader.NumPeaks +
originalPeakIndex);
_peakCount++;
ChromPeak.WriteArray(_outputStreamPeaks.SafeFileHandle, new[] { originalPeak });
}
intensities.Add(originalChromGroup.IntensityArray[originalIndex]
.Skip(minimizedChromGroup.OptimizedFirstScan)
.Take(numPoints).ToArray());
if (massError10Xs != null)
{
massError10Xs.Add(originalChromGroup.MassError10XArray[originalIndex]
.Skip(minimizedChromGroup.OptimizedFirstScan)
.Take(numPoints).ToArray());
}
}
var massError10XArray = massError10Xs != null?massError10Xs.ToArray() : null;
byte[] points = ChromatogramCache.TimeIntensitiesToBytes(times, intensities.ToArray(), massError10XArray, scanIndexes);
// Compress the data (can be huge for AB data with lots of zeros)
byte[] pointsCompressed = points.Compress(3);
int lenCompressed = pointsCompressed.Length;
_outputStream.Write(pointsCompressed, 0, lenCompressed);
var header = new ChromGroupHeaderInfo5(originalHeader.Precursor,
originalHeader.TextIdIndex,
originalHeader.TextIdLen,
fileIndex,
_transitions.Count - startTransitionIndex,
startTransitionIndex,
numPeaks,
startPeakIndex,
startScoreIndex,
maxPeakIndex,
numPoints,
pointsCompressed.Length,
location,
originalHeader.Flags,
originalHeader.StatusId,
originalHeader.StatusRank);
_chromGroupHeaderInfos.Add(header);
}
/// <summary>
/// Decides what information from a ChromatogramGroupInfo should be thrown away.
/// ChromatogramGroupInfo's can have the the retention time range shortened, and certain
/// transitions discarded.
/// </summary>
private MinimizedChromGroup MinimizeChromGroup(Settings settings, ChromatogramGroupInfo chromatogramGroupInfo, IList <TransitionGroupDocNode> transitionGroups)
{
var fileIndexes = new List <int>();
for (int fileIndex = 0; fileIndex < Document.Settings.MeasuredResults.Chromatograms.Count; fileIndex++)
{
var chromatogramSet = Document.Settings.MeasuredResults.Chromatograms[fileIndex];
if (chromatogramSet.MSDataFilePaths.Any(path => Equals(path, chromatogramGroupInfo.FilePath)))
{
fileIndexes.Add(fileIndex);
}
}
var chromatograms = chromatogramGroupInfo.TransitionPointSets.ToArray();
Assume.IsTrue(Equals(chromatogramGroupInfo.NumTransitions, chromatograms.Length));
var keptTransitionIndexes = new List <int>();
double minRetentionTime = Double.MaxValue;
double maxRetentionTime = -Double.MaxValue;
for (int i = 0; i < chromatograms.Length; i++)
{
var chromatogram = chromatograms[i];
var matchingTransitions = new List <TransitionDocNode>();
foreach (var transitionDocNode in transitionGroups.SelectMany(tg => tg.Transitions))
{
if (0 != ChromKey.CompareTolerant((float)chromatogram.ProductMz, (float)transitionDocNode.Mz, _tolerance))
{
continue;
}
matchingTransitions.Add(transitionDocNode);
foreach (var fileIndex in fileIndexes)
{
var chromatogramSet = transitionDocNode.Results[fileIndex];
if (chromatogramSet == null)
{
continue;
}
foreach (var transitionChromInfo in chromatogramSet)
{
if (transitionChromInfo.IsEmpty)
{
continue;
}
minRetentionTime = Math.Min(minRetentionTime, transitionChromInfo.StartRetentionTime);
maxRetentionTime = Math.Max(maxRetentionTime, transitionChromInfo.EndRetentionTime);
}
}
}
bool kept = !settings.DiscardUnmatchedChromatograms ||
matchingTransitions.Count > 0;
if (kept)
{
keptTransitionIndexes.Add(i);
}
}
var result = new MinimizedChromGroup(chromatogramGroupInfo.Header)
{
RetainedTransitionIndexes = keptTransitionIndexes,
};
if (settings.NoiseTimeRange.HasValue && minRetentionTime < maxRetentionTime)
{
if (null == chromatogramGroupInfo.Times)
{
// Chromatogram was unreadable.
result.RetainedTransitionIndexes.Clear();
}
else
{
result.SetStartEndTime(chromatogramGroupInfo.Times, (float)(minRetentionTime - settings.NoiseTimeRange), (float)(maxRetentionTime + settings.NoiseTimeRange));
}
}
return(result);
}
public void WriteChromGroup(ChromatogramGroupInfo originalChromGroup, MinimizedChromGroup minimizedChromGroup)
{
if (minimizedChromGroup.RetainedTransitionIndexes.Count == 0)
{
return;
}
var originalHeader = originalChromGroup.Header;
int fileIndex = originalHeader.FileIndex;
int startTransitionIndex = _transitions.Count;
int startPeakIndex = _peakCount;
int startScoreIndex = _scoreCount;
_scoreCount += minimizedChromGroup.PeakScores.Length;
PrimitiveArrays.Write(_outputStreamScores, minimizedChromGroup.PeakScores);
_peakCount += minimizedChromGroup.TotalPeakCount;
_transitions.AddRange(minimizedChromGroup.Transitions);
var flags = originalHeader.Flags;
MemoryStream pointsStream = new MemoryStream();
var transitionChromSources = minimizedChromGroup.Transitions.Select(tran => tran.Source).ToArray();
var timeIntensitiesGroup = minimizedChromGroup.MinimizedTimeIntensitiesGroup;
if (timeIntensitiesGroup is RawTimeIntensities && _cacheFormat.FormatVersion < CacheFormatVersion.Twelve)
{
timeIntensitiesGroup = ((RawTimeIntensities)minimizedChromGroup.MinimizedTimeIntensitiesGroup)
.Interpolate(transitionChromSources);
}
timeIntensitiesGroup.WriteToStream(pointsStream);
if (timeIntensitiesGroup is RawTimeIntensities)
{
flags |= ChromGroupHeaderInfo.FlagValues.raw_chromatograms;
}
else
{
flags &= ~ChromGroupHeaderInfo.FlagValues.raw_chromatograms;
var interpolatedTimeIntensities = timeIntensitiesGroup as InterpolatedTimeIntensities;
if (interpolatedTimeIntensities != null)
{
flags &=
~(ChromGroupHeaderInfo.FlagValues.has_frag_scan_ids |
ChromGroupHeaderInfo.FlagValues.has_sim_scan_ids |
ChromGroupHeaderInfo.FlagValues.has_ms1_scan_ids);
var scanIdsByChromSource = interpolatedTimeIntensities.ScanIdsByChromSource();
if (scanIdsByChromSource.ContainsKey(ChromSource.fragment))
{
flags |= ChromGroupHeaderInfo.FlagValues.has_frag_scan_ids;
}
if (scanIdsByChromSource.ContainsKey(ChromSource.ms1))
{
flags |= ChromGroupHeaderInfo.FlagValues.has_ms1_scan_ids;
}
if (scanIdsByChromSource.ContainsKey(ChromSource.sim))
{
flags |= ChromGroupHeaderInfo.FlagValues.has_sim_scan_ids;
}
}
}
int numPeaks = minimizedChromGroup.NumPeaks;
int maxPeakIndex = minimizedChromGroup.MaxPeakIndex;
_cacheFormat.ChromPeakSerializer().WriteItems(_outputStreamPeaks, minimizedChromGroup.MinimizedPeaks);
long location = _outputStream.Position;
int lenUncompressed = (int)pointsStream.Length;
byte[] pointsCompressed = pointsStream.ToArray().Compress(3);
int lenCompressed = pointsCompressed.Length;
_outputStream.Write(pointsCompressed, 0, lenCompressed);
int textIdIndex;
int textIdLen;
var newTextId = GetNewTextId(originalHeader);
if (newTextId == null)
{
textIdIndex = -1;
textIdLen = 0;
}
else
{
textIdIndex = CalcTextIdOffset(newTextId);
textIdLen = newTextId.Count;
}
var header = new ChromGroupHeaderInfo(originalHeader.Precursor,
textIdIndex,
textIdLen,
fileIndex,
_transitions.Count - startTransitionIndex,
startTransitionIndex,
numPeaks,
startPeakIndex,
startScoreIndex,
maxPeakIndex,
timeIntensitiesGroup.NumInterpolatedPoints,
lenCompressed,
lenUncompressed,
location,
flags,
originalHeader.StatusId,
originalHeader.StatusRank,
originalHeader.StartTime, originalHeader.EndTime,
originalHeader.CollisionalCrossSection,
originalHeader.IonMobilityUnits);
_chromGroupHeaderInfos.Add(header);
}
private void UpdateStatistics(MinimizedChromGroup minimizedChromGroup)
{
StatisticsCollector.ProcessChromGroup(minimizedChromGroup);
StatisticsCollector.ReportProgress(ProgressCallback, false);
}
/// <summary>
/// Decides what information from a ChromatogramGroupInfo should be thrown away.
/// ChromatogramGroupInfo's can have the the retention time range shortened, and certain
/// transitions discarded.
/// </summary>
private MinimizedChromGroup MinimizeChromGroup(Settings settings, ChromatogramGroupInfo chromatogramGroupInfo, IList <TransitionGroupDocNode> transitionGroups)
{
chromatogramGroupInfo.EnsureDecompressed();
var fileIndexes = new List <int>();
for (int fileIndex = 0; fileIndex < Document.Settings.MeasuredResults.Chromatograms.Count; fileIndex++)
{
var chromatogramSet = Document.Settings.MeasuredResults.Chromatograms[fileIndex];
if (chromatogramSet.MSDataFilePaths.Any(path => Equals(path, chromatogramGroupInfo.FilePath)))
{
fileIndexes.Add(fileIndex);
}
}
var chromatograms = Enumerable.Range(0, chromatogramGroupInfo.NumTransitions)
.Select(chromatogramGroupInfo.GetRawTransitionInfo).ToArray();
Assume.IsTrue(Equals(chromatogramGroupInfo.NumTransitions, chromatograms.Length));
var keptTransitionIndexes = new List <int>();
double minRetentionTime = Double.MaxValue;
double maxRetentionTime = -Double.MaxValue;
for (int i = 0; i < chromatograms.Length; i++)
{
var chromatogram = chromatograms[i];
var matchingTransitions = new List <TransitionDocNode>();
foreach (var transitionDocNode in transitionGroups.SelectMany(tg => tg.Transitions))
{
if (0 != chromatogram.ProductMz.CompareTolerant(transitionDocNode.Mz, _tolerance))
{
continue;
}
matchingTransitions.Add(transitionDocNode);
foreach (var fileIndex in fileIndexes)
{
var chromatogramSet = transitionDocNode.Results[fileIndex];
if (chromatogramSet.IsEmpty)
{
continue;
}
foreach (var transitionChromInfo in chromatogramSet)
{
if (transitionChromInfo.IsEmpty)
{
continue;
}
minRetentionTime = Math.Min(minRetentionTime, transitionChromInfo.StartRetentionTime);
maxRetentionTime = Math.Max(maxRetentionTime, transitionChromInfo.EndRetentionTime);
}
}
}
bool kept = !settings.DiscardUnmatchedChromatograms ||
matchingTransitions.Count > 0 ||
(chromatogram.PrecursorMz.Equals(SignedMz.ZERO) && !settings.DiscardAllIonsChromatograms);
if (kept)
{
keptTransitionIndexes.Add(i);
}
}
var result = new MinimizedChromGroup(chromatogramGroupInfo)
{
RetainedTransitionIndexes = keptTransitionIndexes,
};
if (settings.NoiseTimeRange.HasValue && minRetentionTime < maxRetentionTime)
{
result.SetStartEndTime((float)(minRetentionTime - settings.NoiseTimeRange), (float)(maxRetentionTime + settings.NoiseTimeRange));
}
return(result);
}
