public override bool GetChromatogram( int id, Target modifiedSequence, Color peptideColor, out ChromExtra extra, out TimeIntensities timeIntensities) { bool loaded = false; extra = null; timeIntensities = null; int idRemain = id; for (int iTaskList = 0; iTaskList < _chromatogramRequestProviders.Length; iTaskList++) { ChromatogramRequestProvider requestProvider = _chromatogramRequestProviders[iTaskList]; if (requestProvider.ChromKeys.Count <= idRemain) { idRemain -= requestProvider.ChromKeys.Count; continue; } ChromTaskList chromTaskList = _chromTaskLists[iTaskList]; if (null == chromTaskList) { chromTaskList = _chromTaskLists[iTaskList] = new ChromTaskList(CheckCancelled, _document, _chorusAccount, requestProvider.ChorusUrl, ChromTaskList.ChunkChromatogramRequest(requestProvider.GetChromatogramRequest(), 1000)); chromTaskList.SetMinimumSimultaneousTasks(3); } ChromKey chromKey = requestProvider.ChromKeys[idRemain]; loaded = chromTaskList.GetChromatogram(chromKey, out timeIntensities); if (loaded) { extra = new ChromExtra(id, chromKey.Precursor == 0 ? 0 : -1); if (chromKey.Precursor.IsNegative) { _sourceHasNegativePolarityData = true; } else { _sourceHasPositivePolarityData = true; } if (timeIntensities.NumPoints > 0 && Status is ChromatogramLoadingStatus) { ((ChromatogramLoadingStatus)Status).Transitions.AddTransition( modifiedSequence, peptideColor, extra.StatusId, extra.StatusRank, timeIntensities.Times, timeIntensities.Intensities); } } break; } int percentComplete = _chromTaskLists.Sum(taskList => taskList == null ? 0 : taskList.PercentComplete) / _chromTaskLists.Length; percentComplete = Math.Min(percentComplete, 99); SetPercentComplete(percentComplete); return(loaded); }
public static IPeakFinder CreatePeakFinder(TimeIntensities interpolatedTimeIntensities) { var peakFinder = PeakFinders.NewDefaultPeakFinder(); peakFinder.SetChromatogram(interpolatedTimeIntensities.Times, interpolatedTimeIntensities.Intensities); return(peakFinder); }
/// <summary> /// Get a chromatogram with properly sorted time values. /// </summary> public void ReleaseChromatogram(byte[] bytesFromDisk, out TimeIntensities timeIntensities) { var times = Times.ToArray(bytesFromDisk); var intensities = Intensities.ToArray(bytesFromDisk); var massErrors = MassErrors != null ? MassErrors.ToArray(bytesFromDisk) : null; var scanIds = Scans != null ? Scans.ToArray(bytesFromDisk) : null; // Make sure times and intensities match in length. if (times.Length != intensities.Length) { throw new InvalidDataException( string.Format(Resources.ChromCollected_ChromCollected_Times__0__and_intensities__1__disagree_in_point_count, times.Length, intensities.Length)); } if (massErrors != null && massErrors.Length != intensities.Length) { throw new InvalidDataException( string.Format(Resources.ChromCollector_ReleaseChromatogram_Intensities___0___and_mass_errors___1___disagree_in_point_count_, intensities.Length, massErrors.Length)); } timeIntensities = new TimeIntensities(times, intensities, massErrors, scanIds); // Release memory. Times = null; Intensities = null; MassErrors = null; Scans = null; }
public override bool GetChromatogram(int id, Target modifiedSequence, Color color, out ChromExtra extra, out TimeIntensities timeIntensities) { // No mass errors in SRM if (_readChromatograms == 0) { _readStartTime = DateTime.UtcNow; // Said to be 117x faster than Now and this is for a delta } float[] times, intensities; if (!_globalChromatogramExtractor.GetChromatogram(id, out times, out intensities)) { _dataFile.GetChromatogram(id, out string chromId, out times, out intensities); } timeIntensities = new TimeIntensities(times, intensities, null, null); // Assume that each chromatogram will be read once, though this may // not always be completely true. _readChromatograms++; if (!System.Diagnostics.Debugger.IsAttached) { double predictedMinutes = ExpectedReadDurationMinutes; if (_readMaxMinutes > 0 && predictedMinutes > _readMaxMinutes) { // TODO: This warning isn't checked in the command line version of Skyline. Maybe we should do that. if (Status is ChromatogramLoadingStatus) { Status = ((ChromatogramLoadingStatus)Status).ChangeWarningMessage(Resources.ChromatogramDataProvider_GetChromatogram_This_import_appears_to_be_taking_longer_than_expected__If_importing_from_a_network_drive__consider_canceling_this_import__copying_to_local_disk_and_retrying_); } } } if (_readChromatograms < _chromIds.Count) { SetPercentComplete(50 + _readChromatograms * 50 / _chromIds.Count); } int index = _chromIndices[id]; extra = new ChromExtra(index, -1); // TODO: is zero the right value? // Display in AllChromatogramsGraph var loadingStatus = Status as ChromatogramLoadingStatus; if (loadingStatus != null) { loadingStatus.Transitions.AddTransition( modifiedSequence, color, index, -1, times, intensities); } return(true); }
/// <summary> /// Release a chromatogram if its collector is complete (indicated by retention time). /// </summary> /// <returns>-1 if chromatogram is not finished yet.</returns> public int ReleaseChromatogram( int chromatogramIndex, float retentionTime, ChromCollector collector, out TimeIntensities timeIntensities) { int groupIndex = GetGroupIndex(chromatogramIndex); var spillFile = _spillFiles[groupIndex]; // Not done reading yet. if (retentionTime < spillFile.MaxTime || (collector != null && !collector.IsSetTimes)) { timeIntensities = null; return(-1); } // No chromatogram information collected. if (collector == null) { timeIntensities = TimeIntensities.EMPTY; return(0); } if (ReferenceEquals(_cachedSpillFile, spillFile)) { if (spillFile.Stream != null) { if (_bytesFromSpillFile == null || spillFile.Stream.Length != _bytesFromSpillFile.Length) { // Need to reread spill file if more bytes were written since the time it was cached. _cachedSpillFile = null; } } } if (!ReferenceEquals(_cachedSpillFile, spillFile)) { _cachedSpillFile = spillFile; _bytesFromSpillFile = null; var fileStream = spillFile.Stream; if (fileStream != null) { fileStream.Seek(0, SeekOrigin.Begin); _bytesFromSpillFile = new byte[fileStream.Length]; int bytesRead = fileStream.Read(_bytesFromSpillFile, 0, _bytesFromSpillFile.Length); Assume.IsTrue(bytesRead == _bytesFromSpillFile.Length); // TODO: Would be nice to have something that releases spill files progressively, as they are // no longer needed. // spillFile.CloseStream(); } } collector.ReleaseChromatogram(_bytesFromSpillFile, out timeIntensities); return(collector.StatusId); }
/// <summary> /// Adds the intensities from the other TimeIntensities to the intensities in this. /// The returned TimeIntensities whill have a set of times which is the union of the /// times in this and <paramref name="other"/>. /// </summary> public TimeIntensities MergeTimesAndAddIntensities(TimeIntensities other) { if (Times.Equals(other.Times)) { return(AddIntensities(other)); } var mergedTimes = ImmutableList.ValueOf(Times.Concat(other.Times).Distinct().OrderBy(time => time)); if (mergedTimes.Equals(Times)) { return(AddIntensities(other)); } return(Interpolate(mergedTimes, false).AddIntensities(other)); }
public static RawTimeIntensities FromChromatogramGroupData(ChromatogramGroupData chromatogramGroupData) { var timeIntensitiesList = new List <TimeIntensities>(); var timeLists = chromatogramGroupData.TimeLists.Select(timeList => ImmutableList.ValueOf(timeList.Times)).ToArray(); var scanIdLists = chromatogramGroupData.ScanIdLists .Select(scanIdList => ImmutableList.ValueOf(scanIdList.ScanIds)).ToArray(); foreach (var chromatogram in chromatogramGroupData.Chromatograms) { IEnumerable <float> massErrors = null; if (chromatogram.MassErrors100X.Count > 0) { massErrors = chromatogram.MassErrors100X.Select(error => error / 100.0f); } else if (chromatogram.MassErrorsDeprecated.Count > 0) { massErrors = chromatogram.MassErrorsDeprecated; } var timeIntensities = new TimeIntensities(timeLists[chromatogram.TimeListIndex - 1], chromatogram.Intensities, massErrors, chromatogram.ScanIdListIndex == 0 ? null : scanIdLists[chromatogram.ScanIdListIndex - 1]); timeIntensitiesList.Add(timeIntensities); } InterpolationParams interpolationParams; if (chromatogramGroupData.InterpolatedNumPoints == 0) { interpolationParams = null; } else { interpolationParams = new InterpolationParams(chromatogramGroupData.InterpolatedStartTime, chromatogramGroupData.InterpolatedEndTime, chromatogramGroupData.InterpolatedNumPoints, chromatogramGroupData.InterpolatedDelta) .ChangeInferZeroes(chromatogramGroupData.InferZeroes); } var rawTimeIntensities = new RawTimeIntensities(timeIntensitiesList, interpolationParams); if (chromatogramGroupData.TimeIntervals != null) { var startTimes = chromatogramGroupData.TimeIntervals.StartTimes; var endTimes = chromatogramGroupData.TimeIntervals.EndTimes; var timeIntervals = TimeIntervals.FromIntervals(Enumerable.Range(0, startTimes.Count) .Select(i => new KeyValuePair <float, float>(startTimes[i], endTimes[i]))); rawTimeIntensities = rawTimeIntensities.ChangeTimeIntervals(timeIntervals); } return(rawTimeIntensities); }
/// <summary> /// Adds the intensities from the other TimeIntensities to the intensities in this. /// The returned TimeIntensities will have the same set of times as this. /// </summary> public TimeIntensities AddIntensities(TimeIntensities other) { if (!Times.Equals(other.Times)) { other = other.Interpolate(Times, false); } float[] newIntensities = new float[Times.Count]; for (int i = 0; i < Times.Count; i++) { // Avoid arithmetic overflow double intensitySum = Intensities[i] + other.Intensities[i]; newIntensities[i] = intensitySum < float.MaxValue ? (float)intensitySum : float.MaxValue; } return(new TimeIntensities(Times, newIntensities, null, null)); }
public static InterpolatedTimeIntensities ReadFromStream(Stream stream, ChromGroupHeaderInfo chromGroupHeaderInfo, ChromTransition[] chromTransitions) { Dictionary <ChromSource, int[]> scanIds = new Dictionary <ChromSource, int[]>(); int numTrans = chromTransitions.Length; Assume.IsTrue(numTrans == chromGroupHeaderInfo.NumTransitions); int numPoints = chromGroupHeaderInfo.NumPoints; var sharedTimes = PrimitiveArrays.Read <float>(stream, numPoints); var transitionIntensities = new IList <float> [numTrans]; for (int i = 0; i < numTrans; i++) { transitionIntensities[i] = PrimitiveArrays.Read <float>(stream, numPoints); } IList <float>[] transitionMassErrors = new IList <float> [numTrans]; if (chromGroupHeaderInfo.HasMassErrors) { for (int i = 0; i < numTrans; i++) { transitionMassErrors[i] = ReadMassErrors(stream, numPoints); } } if (chromGroupHeaderInfo.HasFragmentScanIds) { scanIds.Add(ChromSource.fragment, PrimitiveArrays.Read <int>(stream, numPoints)); } if (chromGroupHeaderInfo.HasSimScanIds) { scanIds.Add(ChromSource.sim, PrimitiveArrays.Read <int>(stream, numPoints)); } if (chromGroupHeaderInfo.HasMs1ScanIds) { scanIds.Add(ChromSource.ms1, PrimitiveArrays.Read <int>(stream, numPoints)); } List <TimeIntensities> listOfTimeIntensities = new List <TimeIntensities>(); for (int i = 0; i < numTrans; i++) { var chromSource = chromTransitions[i].Source; int[] transitionScanIds; scanIds.TryGetValue(chromSource, out transitionScanIds); var timeIntensities = new TimeIntensities(sharedTimes, transitionIntensities[i], transitionMassErrors[i], transitionScanIds); listOfTimeIntensities.Add(timeIntensities); } return(new InterpolatedTimeIntensities(listOfTimeIntensities, chromTransitions.Select(chromTransition => chromTransition.Source))); }
public override bool GetChromatogram(int id, Target modifiedSequence, Color color, out ChromExtra extra, out TimeIntensities timeIntensities) { float[] times, intensities; if (!_globalChromatogramExtractor.GetChromatogram(id, out times, out intensities)) { _dataFile.GetChromatogram(id, out _, out times, out intensities); } timeIntensities = new TimeIntensities(times, intensities, null, null); // Assume that each chromatogram will be read once, though this may // not always be completely true. _readChromatograms++; if (_readChromatograms < _chromIds.Count) { SetPercentComplete(50 + _readChromatograms * 50 / _chromIds.Count); } int index = _chromIndices[id]; extra = new ChromExtra(index, -1); // TODO: is zero the right value? // Display in AllChromatogramsGraph var loadingStatus = Status as ChromatogramLoadingStatus; if (loadingStatus != null) { loadingStatus.Transitions.AddTransition( modifiedSequence, color, index, -1, times, intensities); } return(true); }
public override bool GetChromatogram(int id, Target modifiedSequence, Color peptideColor, out ChromExtra extra, out TimeIntensities timeIntensities) { return(_cachedChromatogramDataProvider.GetChromatogram( id, modifiedSequence, peptideColor, out extra, out timeIntensities)); }
public override bool GetChromatogram(int id, Target modifiedSequence, Color peptideColor, out ChromExtra extra, out TimeIntensities timeIntensities) { var chromKeyIndices = _chromKeyIndices[id]; if (_lastChromGroupInfo == null || _lastIndices.GroupIndex != chromKeyIndices.GroupIndex) { _lastChromGroupInfo = _cache.LoadChromatogramInfo(chromKeyIndices.GroupIndex); _lastChromGroupInfo.ReadChromatogram(_cache); } _lastIndices = chromKeyIndices; var tranInfo = _lastChromGroupInfo.GetTransitionInfo(chromKeyIndices.TranIndex); timeIntensities = tranInfo.TimeIntensities; // Assume that each chromatogram will be read once, though this may // not always be completely true. _readChromatograms++; // But avoid reaching 100% before reading is actually complete SetPercentComplete(Math.Min(99, 100 * _readChromatograms / _chromKeyIndices.Length)); extra = new ChromExtra(chromKeyIndices.StatusId, chromKeyIndices.StatusRank); // Display in AllChromatogramsGraph if (chromKeyIndices.Key.Precursor != 0 && Status is ChromatogramLoadingStatus) { ((ChromatogramLoadingStatus)Status).Transitions.AddTransition( modifiedSequence, peptideColor, chromKeyIndices.StatusId, chromKeyIndices.StatusRank, timeIntensities.Times, timeIntensities.Intensities); } return(true); }
public abstract bool GetChromatogram(int id, Target modifiedSequence, Color color, out ChromExtra extra, out TimeIntensities timeIntensities);
public SingletonImpl(TimeIntensities timeIntensities) : base(ImmutableList.Singleton(timeIntensities)) { }
public static TimeIntensitiesGroup Singleton(TimeIntensities timeIntensities) { return(new SingletonImpl(timeIntensities)); }
public PeakIntegrator(TimeIntensities interpolatedTimeIntensities) : this(interpolatedTimeIntensities, null) { }
public void Interpolate(float[] timesNew, bool inferZeros) { var chromatogramTimeIntensities = new TimeIntensities(RawTimes, RawIntensities, RawMassErrors, RawScanIds); TimeIntensities = chromatogramTimeIntensities.Interpolate(timesNew, inferZeros); }
public void FixChromatogram(float[] timesNew, float[] intensitiesNew, int[] scanIndexesNew) { TimeIntensities = RawTimeIntensities = new TimeIntensities(timesNew, intensitiesNew, null, scanIndexesNew); }
public PeakIntegrator(TimeIntensities interpolatedTimeIntensities, IPeakFinder peakFinder) { InterpolatedTimeIntensities = interpolatedTimeIntensities; PeakFinder = peakFinder; }