private MsDataSpectrum GetSpectrumFromJObject(JObject jObject, int msLevel) { // ReSharper disable NonLocalizedString string strMzs = jObject["mzs-base64"].ToString(); string strIntensities = jObject["intensities-base64"].ToString(); byte[] mzBytes = Convert.FromBase64String(strMzs); byte[] intensityBytes = Convert.FromBase64String(strIntensities); double[] mzs = PrimitiveArrays.FromBytes <double>( PrimitiveArrays.ReverseBytesInBlocks(mzBytes, sizeof(double))); float[] intensityFloats = PrimitiveArrays.FromBytes <float>( PrimitiveArrays.ReverseBytesInBlocks(intensityBytes, sizeof(float))); double[] intensities = intensityFloats.Select(f => (double)f).ToArray(); double? driftTime = null; JToken jDriftTime; if (jObject.TryGetValue("driftTime", out jDriftTime)) { driftTime = jDriftTime.ToObject <double>(); } MsDataSpectrum spectrum = new MsDataSpectrum { Index = jObject["index"].ToObject <int>(), RetentionTime = jObject["rt"].ToObject <double>(), Mzs = mzs, Intensities = intensities, DriftTimeMsec = driftTime, }; return(spectrum); // ReSharper restore NonLocalizedString }
private static void WriteString(Stream stream, string str) { var bytes = Encoding.UTF8.GetBytes(str); PrimitiveArrays.WriteOneValue(stream, bytes.Length); stream.Write(bytes, 0, bytes.Length); }
// ReSharper restore LocalizableElement private void WriteCache(ILoadMonitor loader) { using (FileSaver fs = new FileSaver(CachePath, loader.StreamManager)) { using (var stream = loader.StreamManager.CreateStream(fs.SafeName, FileMode.Create, true)) { PrimitiveArrays.WriteOneValue(stream, FORMAT_VERSION_CACHE); PrimitiveArrays.WriteOneValue(stream, _sourceFiles.Count); foreach (var file in _sourceFiles) { byte[] fileNameBytes = Encoding.UTF8.GetBytes(file); PrimitiveArrays.WriteOneValue(stream, fileNameBytes.Length); PrimitiveArrays.Write(stream, fileNameBytes); } PrimitiveArrays.WriteOneValue(stream, _libraryEntries.Length); foreach (var elibSpectrumInfo in _libraryEntries) { elibSpectrumInfo.Write(stream); } loader.StreamManager.Finish(stream); fs.Commit(); loader.StreamManager.SetCache(FilePath, CachePath); } } }
public static ElibSpectrumInfo Read(ValueCache valueCache, Stream stream) { byte[] peptideModSeqBytes = new byte[PrimitiveArrays.ReadOneValue <int>(stream)]; stream.Read(peptideModSeqBytes, 0, peptideModSeqBytes.Length); var peptideModSeq = valueCache.CacheValue(Encoding.UTF8.GetString(peptideModSeqBytes)); int charge = PrimitiveArrays.ReadOneValue <int>(stream); int bestFileId = PrimitiveArrays.ReadOneValue <int>(stream); int peakBoundCount = PrimitiveArrays.ReadOneValue <int>(stream); var peakBounds = new List <KeyValuePair <int, FileData> >(); while (peakBounds.Count < peakBoundCount) { var fileId = PrimitiveArrays.ReadOneValue <int>(stream); var startTime = PrimitiveArrays.ReadOneValue <double>(stream); var endTime = PrimitiveArrays.ReadOneValue <double>(stream); var score = PrimitiveArrays.ReadOneValue <double>(stream); byte bHasApexTime = PrimitiveArrays.ReadOneValue <byte>(stream); double?apexTime; if (bHasApexTime == 0) { apexTime = null; } else { apexTime = PrimitiveArrays.ReadOneValue <double>(stream); } peakBounds.Add(new KeyValuePair <int, FileData>(fileId, new FileData(apexTime, new ExplicitPeakBounds(startTime, endTime, score)))); } return(new ElibSpectrumInfo(peptideModSeq, charge, bestFileId, peakBounds)); }
public override void WriteToStream(Stream stream) { PrimitiveArrays.Write(stream, TransitionTimeIntensities.First().Times.ToArray()); foreach (var timeIntensities in TransitionTimeIntensities) { PrimitiveArrays.Write(stream, timeIntensities.Intensities.ToArray()); } foreach (var timeIntensities in TransitionTimeIntensities) { if (timeIntensities.MassErrors == null) { continue; } WriteMassErrors(stream, timeIntensities.MassErrors); } var scanIdsByChromSource = ScanIdsByChromSource(); foreach (var chromSource in PERSISTED_CHROM_SOURCES) { ImmutableList <int> scanIds; if (!scanIdsByChromSource.TryGetValue(chromSource, out scanIds)) { continue; } PrimitiveArrays.Write(stream, scanIds.ToArray()); } }
private void ReadHeader() { _stream.Seek(-sizeof(long), SeekOrigin.End); _locationHeader = PrimitiveArrays.ReadOneValue <long>(_stream); _stream.Seek(_locationHeader, SeekOrigin.Begin); int version = PrimitiveArrays.ReadOneValue <int>(_stream); if (version > CURRENT_VERSION || version < MIN_READABLE_VERSION) { throw new InvalidDataException(string.Format(Resources.Serializer_ReadHeader_Unsupported_file_version__0_, version)); } _locationEntries = PrimitiveArrays.ReadOneValue <long>(_stream); _library.PanoramaServer = ReadString(_stream); _library.LibraryRevision = PrimitiveArrays.ReadOneValue <int>(_stream); _library.SchemaVersion = ReadString(_stream); var sampleFileCount = PrimitiveArrays.ReadOneValue <int>(_stream); var sampleFiles = new List <ChromatogramLibrarySourceInfo>(); for (int i = 0; i < sampleFileCount; i++) { sampleFiles.Add(ChromatogramLibrarySourceInfo.Read(_stream)); } _library._librarySourceFiles = sampleFiles.ToArray(); _locationEntries = PrimitiveArrays.ReadOneValue <long>(_stream); }
public static LibraryKey Read(ValueCache valueCache, Stream stream) { int length = PrimitiveArrays.ReadOneValue <int>(stream); byte[] buffer = new byte[length]; stream.Read(buffer, 0, length); var proto = new LibraryKeyProto(); proto.MergeFrom(new CodedInputStream(buffer)); switch (proto.KeyType) { case LibraryKeyProto.Types.KeyType.Peptide: return(new PeptideLibraryKey(proto.ModifiedSequence, proto.Charge).ValueFromCache(valueCache)); case LibraryKeyProto.Types.KeyType.PrecursorMz: return(new PrecursorLibraryKey(proto)); case LibraryKeyProto.Types.KeyType.SmallMolecule: return(new MoleculeLibraryKey(valueCache, proto)); case LibraryKeyProto.Types.KeyType.Crosslink: return(new CrosslinkLibraryKey(proto)); } return(null); }
public static ChromatogramLibraryIrt Read(Stream stream) { var seq = Target.FromSerializableString(ReadString(stream)); var timeSource = (TimeSource)PrimitiveArrays.ReadOneValue <int>(stream); var irt = PrimitiveArrays.ReadOneValue <double>(stream); return(new ChromatogramLibraryIrt(seq, timeSource, irt)); }
private static string ReadString(Stream stream) { int byteLength = PrimitiveArrays.ReadOneValue <int>(stream); var bytes = new byte[byteLength]; stream.Read(bytes, 0, bytes.Length); return(Encoding.UTF8.GetString(bytes)); }
public void Write(Stream stream) { var memoryStream = new MemoryStream(); ToLibraryKeyProto().WriteTo(memoryStream); PrimitiveArrays.WriteOneValue(stream, (int)memoryStream.Length); memoryStream.Seek(0, SeekOrigin.Begin); memoryStream.CopyTo(stream); }
public void Write(Stream stream) { Key.Write(stream); PrimitiveArrays.WriteOneValue(stream, Id); PrimitiveArrays.WriteOneValue(stream, PeakArea); RetentionTimesByFileId.Write(stream); PrimitiveArrays.WriteOneValue(stream, TransitionAreas.Count); PrimitiveArrays.Write(stream, TransitionAreas.Select(mi => mi.Mz).ToArray()); PrimitiveArrays.Write(stream, TransitionAreas.Select(mi => mi.Intensity).ToArray()); }
private void WriteData(Block block, Stream fileStream) { // Create back link to previous spilled block. var lastFilePosition = _filePosition; _filePosition = (int)fileStream.Position; PrimitiveArrays.WriteOneValue(fileStream, lastFilePosition); PrimitiveArrays.Write(fileStream, block._data); }
public void Write(Stream stream) { PrimitiveArrays.WriteOneValue(stream, Id); WriteString(stream, FilePath); WriteString(stream, SampleName); WriteString(stream, AcquiredTime); WriteString(stream, ModifiedTime); WriteString(stream, InstrumentIonizationType); WriteString(stream, InstrumentAnalyzer); WriteString(stream, InstrumentDetector); }
private void WriteEntries() { _locationEntries = _stream.Position; PrimitiveArrays.WriteOneValue(_stream, _library._libraryEntries.Length); foreach (var entry in _library._libraryEntries) { entry.Write(_stream); } PrimitiveArrays.WriteOneValue(_stream, _library._libraryIrts.Length); foreach (var entry in _library._libraryIrts) { entry.Write(_stream); } }
public static ChromatogramLibrarySourceInfo Read(Stream stream) { int id = PrimitiveArrays.ReadOneValue <int>(stream); string filePath = ReadString(stream); string sampleName = ReadString(stream); string acquiredTime = ReadString(stream); string modifiedTime = ReadString(stream); string instrumentIonizationType = ReadString(stream); string instrumentAnalyzer = ReadString(stream); string instrumentDetector = ReadString(stream); return(new ChromatogramLibrarySourceInfo(id, filePath, sampleName, acquiredTime, modifiedTime, instrumentIonizationType, instrumentAnalyzer, instrumentDetector)); }
private void WriteHeader() { _locationHeader = _stream.Position; PrimitiveArrays.WriteOneValue(_stream, CURRENT_VERSION); PrimitiveArrays.WriteOneValue(_stream, _locationEntries); WriteString(_stream, _library.PanoramaServer); PrimitiveArrays.WriteOneValue(_stream, _library.LibraryRevision); WriteString(_stream, _library.SchemaVersion); PrimitiveArrays.WriteOneValue(_stream, _library._librarySourceFiles.Length); foreach (var sampleFile in _library._librarySourceFiles) { sampleFile.Write(_stream); } PrimitiveArrays.WriteOneValue(_stream, _locationEntries); PrimitiveArrays.WriteOneValue(_stream, _locationHeader); }
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 static ChromLibSpectrumInfo Read(Stream stream) { LibKey key = LibKey.Read(stream); int id = PrimitiveArrays.ReadOneValue <int>(stream); double peakArea = PrimitiveArrays.ReadOneValue <double>(stream); var retentionTimesByFileId = IndexedRetentionTimes.Read(stream); int mzCount = PrimitiveArrays.ReadOneValue <int>(stream); var mzs = PrimitiveArrays.Read <double>(stream, mzCount); var areas = PrimitiveArrays.Read <float>(stream, mzCount); var mzAreas = ImmutableList.ValueOf(Enumerable.Range(0, mzCount) .Select(index => new SpectrumPeaksInfo.MI { Mz = mzs[index], Intensity = areas[index] })); return(new ChromLibSpectrumInfo(key, id, peakArea, retentionTimesByFileId, mzAreas)); }
private IEnumerable <SpectrumPeaksInfo.MI> ReadSpectrumFromPeptideQuants(SQLiteConnection connection, ElibSpectrumInfo info) { using (var cmd = new SQLiteCommand(connection)) { cmd.CommandText = @"SELECT QuantIonMassLength, QuantIonMassArray, QuantIonIntensityLength, QuantIonIntensityArray FROM peptidequants WHERE PrecursorCharge = ? AND PeptideModSeq = ?"; cmd.Parameters.Add(new SQLiteParameter(DbType.Int32) { Value = info.Key.Charge }); cmd.Parameters.Add(new SQLiteParameter(DbType.String) { Value = info.PeptideModSeq }); SQLiteDataReader reader; try { reader = cmd.ExecuteReader(); } catch (DbException) { // Older .elib files do not have these columns, so just return null return(null); } using (reader) { if (!reader.Read()) { // None of the transitions are considered Quantifiable. return(new SpectrumPeaksInfo.MI[0]); } double[] mzs = PrimitiveArrays.FromBytes <double>( PrimitiveArrays.ReverseBytesInBlocks( UncompressEncyclopeDiaData((byte[])reader.GetValue(1), reader.GetInt32(0)), sizeof(double))); float[] intensities = PrimitiveArrays.FromBytes <float>(PrimitiveArrays.ReverseBytesInBlocks( UncompressEncyclopeDiaData((byte[])reader.GetValue(3), reader.GetInt32(2)), sizeof(float))); return(mzs.Select( (mz, index) => new SpectrumPeaksInfo.MI { Mz = mz, Intensity = intensities[index] })); } } }
private void ReadEntries() { _stream.Seek(_locationEntries, SeekOrigin.Begin); int entryCount = PrimitiveArrays.ReadOneValue <int>(_stream); var entries = new ChromLibSpectrumInfo[entryCount]; for (int i = 0; i < entryCount; i++) { entries[i] = ChromLibSpectrumInfo.Read(_stream); } _library.SetLibraryEntries(entries); int irtCount = PrimitiveArrays.ReadOneValue <int>(_stream); _library._libraryIrts = new ChromatogramLibraryIrt[irtCount]; for (int i = 0; i < irtCount; i++) { _library._libraryIrts[i] = ChromatogramLibraryIrt.Read(_stream); } }
private IEnumerable <SpectrumPeaksInfo.MI> ReadSpectrumFromEntriesTable(SQLiteConnection connection, ElibSpectrumInfo info, int sourceFileId) { using (var cmd = new SQLiteCommand(connection)) { cmd.CommandText = @"SELECT MassEncodedLength, MassArray, IntensityEncodedLength, IntensityArray FROM entries WHERE PrecursorCharge = ? AND PeptideModSeq = ? AND SourceFile = ?"; cmd.Parameters.Add(new SQLiteParameter(DbType.Int32) { Value = info.Key.Charge }); cmd.Parameters.Add(new SQLiteParameter(DbType.String) { Value = info.PeptideModSeq }); cmd.Parameters.Add(new SQLiteParameter(DbType.String) { Value = _sourceFiles[sourceFileId] }); using (var reader = cmd.ExecuteReader()) { if (reader.Read()) { double[] mzs = PrimitiveArrays.FromBytes <double>( PrimitiveArrays.ReverseBytesInBlocks( UncompressEncyclopeDiaData((byte[])reader.GetValue(1), reader.GetInt32(0)), sizeof(double))); float[] intensities = PrimitiveArrays.FromBytes <float>(PrimitiveArrays.ReverseBytesInBlocks( UncompressEncyclopeDiaData((byte[])reader.GetValue(3), reader.GetInt32(2)), sizeof(float))); return(mzs.Select((mz, index) => new SpectrumPeaksInfo.MI { Mz = mz, Intensity = intensities[index], }) // CONSIDER(bspratt): annotation? .ToArray()); } return(null); } } }
private bool LoadFromCache(ILoadMonitor loader) { if (!loader.StreamManager.IsCached(FilePath, CachePath)) { return(false); } try { ValueCache valueCache = new ValueCache(); using (var stream = loader.StreamManager.CreateStream(CachePath, FileMode.Open, true)) { int version = PrimitiveArrays.ReadOneValue <int>(stream); if (version != FORMAT_VERSION_CACHE) { return(false); } int fileCount = PrimitiveArrays.ReadOneValue <int>(stream); List <String> sourceFiles = new List <string>(fileCount); while (sourceFiles.Count < fileCount) { int byteCount = PrimitiveArrays.ReadOneValue <int>(stream); byte[] bytes = new byte[byteCount]; stream.Read(bytes, 0, bytes.Length); sourceFiles.Add(Encoding.UTF8.GetString(bytes)); } int spectrumInfoCount = PrimitiveArrays.ReadOneValue <int>(stream); _sourceFiles = ImmutableList.ValueOf(sourceFiles); List <ElibSpectrumInfo> spectrumInfos = new List <ElibSpectrumInfo>(); while (spectrumInfos.Count < spectrumInfoCount) { spectrumInfos.Add(ElibSpectrumInfo.Read(valueCache, stream)); } SetLibraryEntries(spectrumInfos); return(true); } } catch (Exception exception) { Trace.TraceWarning(@"Exception loading cache: {0}", exception); return(false); } }
public static byte[] ToBytes(IEnumerable <string> scanIds) { var listStartBytes = new List <int>(); var listLengths = new List <int>(); var listIdBytes = new List <byte>(); foreach (var scanId in scanIds) { int len = Encoding.UTF8.GetByteCount(scanId); var buffer = new byte[len]; Encoding.UTF8.GetBytes(scanId, 0, scanId.Length, buffer, 0); listStartBytes.Add(listIdBytes.Count); listLengths.Add(len); listIdBytes.AddRange(buffer); } if (listStartBytes.Count == 0) { return(new byte[0]); } var listEntryBytes = new List <byte>(); listEntryBytes.AddRange(PrimitiveArrays.ToBytes(listStartBytes.ToArray())); listEntryBytes.AddRange(PrimitiveArrays.ToBytes(listLengths.ToArray())); var entryBytes = listEntryBytes.ToArray(); var entryBytesCompressed = entryBytes.Compress(); var scanIdBytes = listIdBytes.ToArray(); var scanIdBytesCompressed = scanIdBytes.Compress(); var listResultBytes = new List <byte>(); listResultBytes.AddRange(BitConverter.GetBytes(entryBytes.Length)); listResultBytes.AddRange(BitConverter.GetBytes(entryBytesCompressed.Length)); listResultBytes.AddRange(BitConverter.GetBytes(scanIdBytes.Length)); listResultBytes.AddRange(BitConverter.GetBytes(scanIdBytesCompressed.Length)); listResultBytes.AddRange(entryBytesCompressed); listResultBytes.AddRange(scanIdBytesCompressed); return(listResultBytes.ToArray()); }
public void Write(Stream stream) { PrimitiveArrays.WriteOneValue(stream, PeptideModSeq.Length); PrimitiveArrays.Write(stream, Encoding.UTF8.GetBytes(PeptideModSeq)); PrimitiveArrays.WriteOneValue(stream, Key.Charge); PrimitiveArrays.WriteOneValue(stream, BestFileId); PrimitiveArrays.WriteOneValue(stream, FileDatas.Count); foreach (var peakBoundEntry in FileDatas) { PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Key); PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Value.PeakBounds.StartTime); PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Value.PeakBounds.EndTime); if (peakBoundEntry.Value.ApexTime.HasValue) { PrimitiveArrays.WriteOneValue <byte>(stream, 1); PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Value.ApexTime.Value); } else { PrimitiveArrays.WriteOneValue <byte>(stream, 0); } } }
private MsDataSpectrum GetSpectrumFromJObject(JObject jObject, int msLevel) { // ReSharper disable NonLocalizedString string strMzs = jObject["mzs-base64"].ToString(); string strIntensities = jObject["intensities-base64"].ToString(); byte[] mzBytes = Convert.FromBase64String(strMzs); byte[] intensityBytes = Convert.FromBase64String(strIntensities); double[] mzs = PrimitiveArrays.FromBytes <double>( PrimitiveArrays.ReverseBytesInBlocks(mzBytes, sizeof(double))); float[] intensityFloats = PrimitiveArrays.FromBytes <float>( PrimitiveArrays.ReverseBytesInBlocks(intensityBytes, sizeof(float))); double[] intensities = intensityFloats.Select(f => (double)f).ToArray(); IonMobilityValue ionMobility = IonMobilityValue.EMPTY; JToken jDriftTime; if (jObject.TryGetValue("driftTime", out jDriftTime)) { var driftTime = jDriftTime.ToObject <double>(); if (driftTime != 0) { ionMobility = IonMobilityValue.GetIonMobilityValue(driftTime, MsDataFileImpl.eIonMobilityUnits.drift_time_msec); } } MsDataSpectrum spectrum = new MsDataSpectrum { Index = jObject["index"].ToObject <int>(), RetentionTime = jObject["rt"].ToObject <double>(), Mzs = mzs, Intensities = intensities, IonMobility = ionMobility, }; return(spectrum); // ReSharper restore NonLocalizedString }
public static MsDataFileScanIds FromBytes(byte[] byteArray) { if (byteArray.Length == 0) { return(null); } int i = 0; int entryBytesCount = GetInt(i++, byteArray); int entryBytesCompressedCount = GetInt(i++, byteArray); int scanIdBytesCount = GetInt(i++, byteArray); int scanIdBytesCompressedCount = GetInt(i++, byteArray); var entryBytesCompressed = new byte[entryBytesCompressedCount]; Array.Copy(byteArray, i * sizeof(int), entryBytesCompressed, 0, entryBytesCompressedCount); var entryBytes = entryBytesCompressed.Uncompress(entryBytesCount); var startBytesArray = new byte[entryBytes.Length / 2]; Array.Copy(entryBytes, 0, startBytesArray, 0, startBytesArray.Length); var startBytes = PrimitiveArrays.FromBytes <int>(startBytesArray); var lengthBytesArray = new byte[entryBytes.Length / 2]; Array.Copy(entryBytes, startBytesArray.Length, lengthBytesArray, 0, lengthBytesArray.Length); var lengths = PrimitiveArrays.FromBytes <int>(lengthBytesArray); Assume.IsTrue(startBytesArray.Length + lengthBytesArray.Length == entryBytes.Length); var scanIdBytesCompressed = new byte[scanIdBytesCompressedCount]; Array.Copy(byteArray, i * sizeof(int) + entryBytesCompressedCount, scanIdBytesCompressed, 0, scanIdBytesCompressedCount); var scanIdBytes = scanIdBytesCompressed.Uncompress(scanIdBytesCount); return(new MsDataFileScanIds(startBytes, lengths, scanIdBytes)); }
private static float[] ReadMassErrors(Stream stream, int count) { return(PrimitiveArrays.Read <short>(stream, count).Select(value => value / 10f).ToArray()); }
private static void WriteMassErrors(Stream stream, IList <float> values) { PrimitiveArrays.Write(stream, values.Select(value => ChromPeak.To10x(value)).ToArray()); }
private bool Load(ILoadMonitor loader, IProgressStatus status, bool cached) { try { int loadPercent = 100; if (!cached) { // Building the cache will take 95% of the load time. loadPercent = 5; status = status.ChangeMessage(string.Format(Resources.XHunterLibrary_Load_Building_binary_cache_for__0__library, Path.GetFileName(FilePath))); status = status.ChangePercentComplete(0); loader.UpdateProgress(status); if (!CreateCache(loader, status, 100 - loadPercent)) { return(false); } } status = status.ChangeMessage(string.Format(Resources.XHunterLibrary_Load_Loading__0__library, Path.GetFileName(FilePath))); loader.UpdateProgress(status); var valueCache = new ValueCache(); var sm = loader.StreamManager; using (Stream stream = sm.CreateStream(CachePath, FileMode.Open, true)) { // Read library header from the end of the cache int countHeader = (int)LibHeaders.count * sizeof(int); stream.Seek(-countHeader, SeekOrigin.End); byte[] libHeader = new byte[countHeader]; ReadComplete(stream, libHeader, countHeader); int version = GetInt32(libHeader, (int)LibHeaders.format_version); if (version != FORMAT_VERSION_CACHE) { return(false); } int countRevisionBytes = GetInt32(libHeader, (int)LibHeaders.revision_byte_count); int countIdBytes = GetInt32(libHeader, (int)LibHeaders.id_byte_count); stream.Seek(-countHeader - countRevisionBytes - countIdBytes, SeekOrigin.End); Revision = ReadString(stream, countRevisionBytes); Id = ReadString(stream, countIdBytes); int numSpectra = GetInt32(libHeader, (int)LibHeaders.num_spectra); var libraryEntries = new XHunterSpectrumInfo[numSpectra]; // Seek to beginning of spectrum headers long locationHeaders = BitConverter.ToInt64(libHeader, ((int)LibHeaders.location_headers_lo) * sizeof(int)); stream.Seek(locationHeaders, SeekOrigin.Begin); for (int i = 0; i < numSpectra; i++) { int percent = (100 - loadPercent) + (i * loadPercent / numSpectra); if (status.PercentComplete != percent) { // Check for cancellation after each integer change in percent loaded. if (loader.IsCanceled) { loader.UpdateProgress(status.Cancel()); return(false); } // If not cancelled, update progress. loader.UpdateProgress(status = status.ChangePercentComplete(percent)); } // Read spectrum header LibKey key = LibKey.Read(valueCache, stream); long location = PrimitiveArrays.ReadOneValue <long>(stream); float processedIntensity = PrimitiveArrays.ReadOneValue <float>(stream); int numPeaks = PrimitiveArrays.ReadOneValue <int>(stream); float expect = PrimitiveArrays.ReadOneValue <float>(stream); libraryEntries[i] = new XHunterSpectrumInfo(key, processedIntensity, expect, (short)numPeaks, location); } // Checksum = checksum.ChecksumValue; SetLibraryEntries(libraryEntries); loader.UpdateProgress(status.Complete()); // Create the stream from which the spectra will be read CreateStream(loader); } return(true); } catch (InvalidDataException x) { if (!cached) { loader.UpdateProgress(status.ChangeErrorException(x)); } return(false); } catch (IOException x) { if (!cached) { loader.UpdateProgress(status.ChangeErrorException(x)); } return(false); } catch (Exception x) { if (!cached) { x = new Exception(string.Format(Resources.XHunterLibrary_Load_Failed_loading_library__0__, FilePath), x); loader.UpdateProgress(status.ChangeErrorException(x)); } return(false); } finally { if (ReadStream != null) { // Close the read stream to ensure we never leak it. // This only costs on extra open, the first time the // active document tries to read. try { ReadStream.CloseStream(); } catch (IOException) { } } } }
// ReSharper restore UnusedMember.Local private bool CreateCache(ILoadMonitor loader, IProgressStatus status, int percent) { var sm = loader.StreamManager; BufferedStream stream = new BufferedStream(CreateStream(loader), 32 * 1024); int version = 1; string id = string.Empty, revision = string.Empty; int size = ReadSize(stream); int i; if (size == 0) { version = 2; size = ReadSize(stream); const int countLibHeader = 256 - 8; byte[] libHeader = new byte[countLibHeader]; if (stream.Read(libHeader, 0, libHeader.Length) != libHeader.Length) { throw new InvalidDataException(Resources.XHunterLibrary_CreateCache_Data_truncation_in_library_header_File_may_be_corrupted); } for (i = 0; i < libHeader.Length; i++) { if (libHeader[i] == 0) { break; } } string header = Encoding.UTF8.GetString(libHeader, 0, i); Match match = REGEX_HEADER.Match(header); if (match.Success) { version = int.Parse(match.Groups[1].Value); id = match.Groups[2].Value; revision = match.Groups[3].Value; } } var setLibKeys = new HashSet <LibKey>(size); var libraryEntries = new List <XHunterSpectrumInfo>(size); const int countHeader = ((int)SpectrumHeaders2.count) * sizeof(int); byte[] specHeader = new byte[1024]; byte[] specSequence = new byte[1024]; i = 0; while (stream.Read(specHeader, 0, countHeader) == countHeader) { int percentComplete = (i++ *percent / size); if (status.PercentComplete != percentComplete) { // Check for cancellation after each integer change in percent loaded. if (loader.IsCanceled) { loader.UpdateProgress(status.Cancel()); return(false); } // If not cancelled, update progress. loader.UpdateProgress(status = status.ChangePercentComplete(percentComplete)); } int charge = (version == 1 ? GetInt32(specHeader, ((int)SpectrumHeaders1.charge)) : GetInt32(specHeader, ((int)SpectrumHeaders2.charge))); float i2 = (version == 1 ? GetSingle(specHeader, ((int)SpectrumHeaders1.i2)) : GetSingle(specHeader, ((int)SpectrumHeaders2.i2))); int seqLength = (version == 1 ? GetInt32(specHeader, ((int)SpectrumHeaders1.seq_len)) : GetInt32(specHeader, ((int)SpectrumHeaders2.seq_len))); float expect = (version == 1 ? 0.001f : GetSingle(specHeader, (int)SpectrumHeaders2.expect)); // Read sequence information ReadComplete(stream, specSequence, seqLength); specSequence[seqLength] = 0; short numPeaks = (short)ReadSize(stream); // Save spectrum location long location = stream.Position; // Read over spectrum int countPeaks = (sizeof(byte) + sizeof(float)) * numPeaks; stream.Seek(countPeaks, SeekOrigin.Current); // Skip spectrum // Read modifications int numMods = ReadSize(stream); string modifiedSequence = Encoding.UTF8.GetString(specSequence, 0, seqLength); if (numMods > 0) { StringBuilder sb = new StringBuilder(); ReadComplete(stream, specHeader, (4 + sizeof(double)) * numMods); int iLast = 0; double modTotal = 0; for (int j = 0; j < numMods; j++) { int iPos = GetInt32(specHeader, j * 3); double mod = BitConverter.ToDouble(specHeader, (j * 3 + 1) * 4); // X! Hunter allows multiple modifications on the same // residue. So, they need to be totaled, and assigned to a // single residue to allow them to match Skyline modification // settings. if (iPos > iLast) { if (modTotal != 0) { sb.Append(SequenceMassCalc.GetModDiffDescription(modTotal)); } sb.Append(Encoding.UTF8.GetString(specSequence, iLast, iPos - iLast)); modTotal = 0; } modTotal += mod; iLast = iPos; } if (modTotal != 0) { sb.Append(SequenceMassCalc.GetModDiffDescription(modTotal)); } sb.Append(Encoding.UTF8.GetString(specSequence, iLast, seqLength - iLast)); modifiedSequence = sb.ToString(); } // Skip over homologs (list of protein IDs and start positions from a FASTA // file used to generate the library) int numHomologs = ReadSize(stream); for (int j = 0; j < numHomologs; j++) { stream.Seek(ReadSize(stream) + 4, SeekOrigin.Current); } // These libraries should not have duplicates, but just in case. // Apparently, GPM libraries do contain redundancies, as we found // when a revision lost this test. var key = new LibKey(modifiedSequence, charge); if (setLibKeys.Add(key)) { libraryEntries.Add(new XHunterSpectrumInfo(key, i2, expect, numPeaks, location)); } } libraryEntries = FilterInvalidLibraryEntries(ref status, libraryEntries); using (FileSaver fs = new FileSaver(CachePath, sm)) using (Stream outStream = sm.CreateStream(fs.SafeName, FileMode.Create, true)) { foreach (var info in libraryEntries) { info.Key.Write(outStream); PrimitiveArrays.WriteOneValue(outStream, info.Location); PrimitiveArrays.WriteOneValue(outStream, info.ProcessedIntensity); PrimitiveArrays.WriteOneValue(outStream, info.NumPeaks); PrimitiveArrays.WriteOneValue(outStream, info.Expect); } byte[] revisionBytes = Encoding.UTF8.GetBytes(revision); outStream.Write(revisionBytes, 0, revisionBytes.Length); byte[] idBytes = Encoding.UTF8.GetBytes(id); outStream.Write(idBytes, 0, idBytes.Length); outStream.Write(BitConverter.GetBytes(revisionBytes.Length), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes(idBytes.Length), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes(FORMAT_VERSION_CACHE), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes(libraryEntries.Count), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes((long)0), 0, sizeof(long)); sm.Finish(outStream); fs.Commit(); sm.SetCache(FilePath, CachePath); } loader.UpdateProgress(status.Complete()); return(true); }