private bool Load(ILoadMonitor loader)
{
ProgressStatus status = new ProgressStatus(string.Format(Resources.ChromatogramLibrary_Load_Loading__0_, Name));
loader.UpdateProgress(status);
if (LoadFromCache(loader, status))
{
loader.UpdateProgress(status.Complete());
return(true);
}
if (LoadLibraryFromDatabase(loader))
{
using (var fileSaver = new FileSaver(CachePath, loader.StreamManager))
{
using (var stream = loader.StreamManager.CreateStream(fileSaver.SafeName, FileMode.Create, true))
{
var serializer = new Serializer(this, stream);
serializer.Write();
loader.StreamManager.Finish(stream);
fileSaver.Commit();
loader.StreamManager.SetCache(FilePath, CachePath);
}
}
loader.UpdateProgress(status.Complete());
return(true);
}
return(false);
}
private bool Load(ILoadMonitor loader)
{
ProgressStatus status = new ProgressStatus(string.Empty);
loader.UpdateProgress(status);
bool cached = loader.StreamManager.IsCached(FilePath, CachePath);
if (Load(loader, status, cached))
{
return(true);
}
// If loading from the cache failed, rebuild it.
if (cached)
{
// Reset readStream so we don't read corrupt file.
_readStream = null;
if (Load(loader, status, false))
{
return(true);
}
}
return(false);
}
private bool Load(ILoadMonitor loader)
{
try
{
if (LoadFromCache(loader))
{
return(true);
}
if (LoadLibraryFromDatabase(loader))
{
WriteCache(loader);
return(true);
}
}
catch (Exception e)
{
if (!loader.IsCanceled)
{
var msgException = new ApplicationException(string.Format(Resources.BiblioSpecLiteLibrary_Load_Failed_loading_library__0__, FilePath), e);
loader.UpdateProgress(new ProgressStatus().ChangeErrorException(msgException));
}
}
return(false);
}
public Digestion Digest(Enzyme enzyme, DigestSettings digestSettings, ILoadMonitor loader)
{
IProgressStatus progressStatus = new ProgressStatus(string.Format(Resources.BackgroundProteomeSpec_Digest_Digesting__0__, enzyme.Name));
loader.UpdateProgress(progressStatus);
using (var proteomeDb = OpenProteomeDb())
{
return(proteomeDb.Digest(new ProteaseImpl(enzyme), digestSettings.MaxMissedCleavages, loader, ref progressStatus));
}
}
public Digestion Digest(Enzyme enzyme, DigestSettings digestSettings, ILoadMonitor loader)
{
ProgressStatus progressStatus = new ProgressStatus(string.Format(Resources.BackgroundProteomeSpec_Digest_Digesting__0__, enzyme.Name));
using (var proteomeDb = OpenProteomeDb())
{
return(proteomeDb.Digest(new ProteaseImpl(enzyme),
(s, i) =>
{
loader.UpdateProgress(progressStatus.ChangePercentComplete(i));
return !loader.IsCanceled;
}));
}
}
public bool CompleteDocument(SrmDocument document, ILoadMonitor loadMonitor)
{
// Refuse completion, if anything is still not final
var status = Status;
var notFinal = status.ProgressList.Where(s => !s.IsFinal).ToArray();
if (notFinal.Any())
{
// Write output in attempt to associate new hangs in nightly tests with the return false below
// Console.WriteLine(TextUtil.LineSeparate(@"*** Attempt to complete document with non-final status ***",
// TextUtil.LineSeparate(notFinal.Select(s => string.Format(@"{0} {1}% - {2}", s.State, s.PercentComplete, s.FilePath)))));
return(false);
}
if (status.ProgressList.Any())
{
loadMonitor.UpdateProgress(CompleteStatus());
}
ClearDocument(document);
return(true);
}
// 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);
}
public static void AddSpectra(MidasLibSpec libSpec, MsDataFilePath[] resultsFiles, SrmDocument doc, ILoadMonitor monitor, out List <MsDataFilePath> failedFiles)
{
// Get spectra from results files
var newSpectra = new List <DbSpectrum>();
var progress = new ProgressStatus(string.Empty).ChangeMessage(Resources.MidasLibrary_AddSpectra_Reading_MIDAS_spectra);
const int percentResultsFiles = 80;
failedFiles = new List <MsDataFilePath>();
for (var i = 0; i < resultsFiles.Length; i++)
{
var resultsFile = resultsFiles[i];
try
{
monitor.UpdateProgress(progress.ChangePercentComplete(i * percentResultsFiles / resultsFiles.Length));
var filePath = resultsFile.GetFilePath();
if (File.Exists(filePath))
{
var sampleIndex = resultsFile.GetSampleIndex();
using (var msd = new MsDataFileImpl(filePath, sampleIndex == -1 ? 0 : sampleIndex, resultsFile.GetLockMassParameters(), requireVendorCentroidedMS2: true))
{
if (ChromatogramDataProvider.HasChromatogramData(msd) && SpectraChromDataProvider.HasSpectrumData(msd))
{
var chromPrecursors = ReadChromPrecursorsFromMsd(msd, monitor).ToList();
newSpectra.AddRange(ReadDbSpectraFromMsd(msd, monitor));
MatchSpectraToChrom(newSpectra, chromPrecursors, monitor);
}
}
MatchSpectraToPeptides(newSpectra, doc, monitor);
}
else
{
failedFiles.Add(resultsFile);
}
}
catch (Exception x)
{
monitor.UpdateProgress(progress.ChangeErrorException(x));
failedFiles.Add(resultsFile);
}
if (monitor.IsCanceled)
{
monitor.UpdateProgress(progress.Cancel());
return;
}
}
if (!newSpectra.Any())
{
monitor.UpdateProgress(progress.Complete());
return;
}
progress = progress.ChangePercentComplete(percentResultsFiles);
monitor.UpdateProgress(progress);
// Add spectra to library
var midasLib = !File.Exists(libSpec.FilePath) ? Create(libSpec) : Load(libSpec, monitor);
if (midasLib == null)
{
monitor.UpdateProgress(progress.ChangeErrorException(new Exception(Resources.MidasLibrary_AddSpectra_Error_loading_MIDAS_library_for_adding_spectra_)));
return;
}
progress = progress.ChangeMessage(Resources.MidasLibrary_AddSpectra_Adding_spectra_to_MIDAS_library);
monitor.UpdateProgress(progress);
var results = new Dictionary <string, DbResultsFile>();
if (midasLib._spectra != null)
{
foreach (var kvp in midasLib._spectra)
{
results[kvp.Key.FilePath] = kvp.Key;
}
}
using (var sessionFactory = SessionFactoryFactory.CreateSessionFactory(libSpec.FilePath, typeof(MidasLibrary), false))
using (var session = new SessionWithLock(sessionFactory.OpenSession(), new ReaderWriterLock(), true))
using (var transaction = session.BeginTransaction())
{
for (var i = 0; i < newSpectra.Count; i++)
{
if (monitor.IsCanceled)
{
transaction.Rollback();
monitor.UpdateProgress(progress.Cancel());
return;
}
var spectrum = newSpectra[i];
monitor.UpdateProgress(progress.ChangePercentComplete(percentResultsFiles + (int)(100.0 * i / newSpectra.Count)));
DbResultsFile resultsFile;
if (!results.TryGetValue(spectrum.ResultsFile.FilePath, out resultsFile))
{
resultsFile = new DbResultsFile(spectrum.ResultsFile)
{
Id = null
};
results[spectrum.ResultsFile.FilePath] = resultsFile;
session.SaveOrUpdate(resultsFile);
}
else if (midasLib._spectra != null)
{
List <DbSpectrum> existingSpectra;
if (midasLib._spectra.TryGetValue(resultsFile, out existingSpectra) &&
existingSpectra.Any(x => Equals(x.ResultsFile.FilePath, spectrum.ResultsFile.FilePath) &&
Equals(x.PrecursorMz, spectrum.PrecursorMz) &&
Equals(x.RetentionTime, spectrum.RetentionTime)))
{
// This spectrum already exists in the library
continue;
}
}
var spectrumNewDisconnected = new DbSpectrum(spectrum)
{
Id = null, ResultsFile = resultsFile
};
session.SaveOrUpdate(spectrumNewDisconnected);
}
transaction.Commit();
monitor.UpdateProgress(progress.Complete());
}
}
// ReSharper disable LocalizableElement
private bool LoadLibraryFromDatabase(ILoadMonitor loader)
{
var status = new ProgressStatus(
string.Format(Resources.ChromatogramLibrary_LoadLibraryFromDatabase_Reading_precursors_from__0_,
Name));
try
{
loader.UpdateProgress(status);
var libKeySourceFileDatas = new Dictionary <Tuple <string, int>, Dictionary <string, Tuple <double?, FileData> > >();
var scores = new EncyclopeDiaScores();
scores.ReadScores(_pooledSqliteConnection.Connection);
HashSet <Tuple <string, int> > quantPeptides = new HashSet <Tuple <string, int> >();
using (var cmd = new SQLiteCommand(_pooledSqliteConnection.Connection))
{
// From the "entries" table, read all of the peptides that were actually found
cmd.CommandText =
"SELECT PeptideModSeq, PrecursorCharge, SourceFile, Score, RTInSeconds, RTInSecondsStart, RTInSecondsStop FROM entries";
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
if (loader.IsCanceled)
{
throw new OperationCanceledException();
}
var libKey = Tuple.Create(reader.GetString(0), Convert.ToInt32(reader.GetValue(1)));
// Tuple of filename, score, FileData
Dictionary <string, Tuple <double?, FileData> > dataByFilename;
if (!libKeySourceFileDatas.TryGetValue(libKey, out dataByFilename))
{
dataByFilename = new Dictionary <string, Tuple <double?, FileData> >();
libKeySourceFileDatas.Add(libKey, dataByFilename);
}
string fileName = reader.GetString(2);
if (dataByFilename.ContainsKey(fileName))
{
continue;
}
double score = reader.GetDouble(3);
var qValue = scores.GetQValue(libKey.Item1, libKey.Item2, fileName) ??
ExplicitPeakBounds.UNKNOWN_SCORE;
dataByFilename.Add(fileName, Tuple.Create((double?)score,
new FileData(reader.GetDouble(4) / 60,
new ExplicitPeakBounds(reader.GetDouble(5) / 60, reader.GetDouble(6) / 60, qValue))));
}
}
// Also, read the PeptideQuants table in order to get peak boundaries for any peptide&sourcefiles that were
// not found in the Entries table.
cmd.CommandText =
"SELECT PeptideModSeq, PrecursorCharge, SourceFile, RTInSecondsStart, RTInSecondsStop FROM PeptideQuants";
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var libKey = Tuple.Create(reader.GetString(0), Convert.ToInt32(reader.GetValue(1)));
quantPeptides.Add(libKey);
// Tuple of filename, score, FileData
Dictionary <string, Tuple <double?, FileData> > dataByFilename;
if (!libKeySourceFileDatas.TryGetValue(libKey, out dataByFilename))
{
dataByFilename = new Dictionary <string, Tuple <double?, FileData> >();
libKeySourceFileDatas.Add(libKey, dataByFilename);
}
string fileName = reader.GetString(2);
if (dataByFilename.ContainsKey(fileName))
{
continue;
}
double qValue = scores.GetQValue(libKey.Item1, libKey.Item2, fileName) ??
ExplicitPeakBounds.UNKNOWN_SCORE;
dataByFilename.Add(fileName,
Tuple.Create((double?)null,
new FileData(null, new ExplicitPeakBounds(reader.GetDouble(3) / 60, reader.GetDouble(4) / 60, qValue))));
}
}
}
// ReSharper disable PossibleMultipleEnumeration
var sourceFiles = libKeySourceFileDatas
.SelectMany(entry => entry.Value.Keys)
.Distinct()
.ToArray();
Array.Sort(sourceFiles);
var sourceFileIds = sourceFiles.Select((file, index) => Tuple.Create(file, index))
.ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);
var spectrumInfos = libKeySourceFileDatas
.Where(entry => quantPeptides.Contains(entry.Key))
.Select(entry => MakeSpectrumInfo(entry.Key.Item1, entry.Key.Item2, entry.Value, sourceFileIds));
SetLibraryEntries(spectrumInfos);
_sourceFiles = ImmutableList.ValueOf(sourceFiles);
// ReSharper restore PossibleMultipleEnumeration
loader.UpdateProgress(status.Complete());
return(true);
}
catch (Exception e)
{
e = new InvalidDataException(string.Format(Resources.BiblioSpecLiteLibrary_Load_Failed_loading_library__0__, FilePath), e);
loader.UpdateProgress(status.ChangeErrorException(e));
return(false);
}
}
public Digestion Digest(Enzyme enzyme, DigestSettings digestSettings, ILoadMonitor loader)
{
ProgressStatus progressStatus = new ProgressStatus(string.Format(Resources.BackgroundProteomeSpec_Digest_Digesting__0__, enzyme.Name));
using (var proteomeDb = OpenProteomeDb())
{
return proteomeDb.Digest(new ProteaseImpl(enzyme),
(s, i) =>
{
loader.UpdateProgress(progressStatus.ChangePercentComplete(i));
return !loader.IsCanceled;
});
}
}
private bool LoadLibraryFromDatabase(ILoadMonitor loader)
{
try
{
var status = new ProgressStatus(string.Format(Resources.ChromatogramLibrary_LoadLibraryFromDatabase_Reading_precursors_from__0_, Name));
loader.UpdateProgress(status);
// _pooledSessionFactory = new PooledSessionFactory(loader.StreamManager.ConnectionPool,
// typeof (ChromLibEntity), FilePath);
using (var session = _pooledSessionFactory.Connection.OpenSession())
{
var libInfo =
session.CreateSQLQuery("SELECT PanoramaServer, LibraryRevision, SchemaVersion FROM LibInfo") // Not L10N
.UniqueResult <object[]>();
PanoramaServer = Convert.ToString(libInfo[0]);
LibraryRevision = Convert.ToInt32(libInfo[1]);
SchemaVersion = Convert.ToString(libInfo[2]);
try
{
var irtQuery = session.CreateQuery("SELECT PeptideModSeq, Irt, TimeSource FROM IrtLibrary"); // Not L10N
_libraryIrts = irtQuery.List <object[]>().Select(
irt => new ChromatogramLibraryIrt(new Target((string)irt[0]), (TimeSource)irt[2], Convert.ToDouble(irt[1]))
).ToArray();
}
catch (GenericADOException)
{
// IrtLibrary table probably doesn't exist
}
var rtQuery = session.CreateQuery("SELECT Precursor.Id, SampleFile.Id, RetentionTime FROM PrecursorRetentionTime"); // Not L10N
var rtDictionary = new Dictionary <int, List <KeyValuePair <int, double> > >(); // PrecursorId -> [SampleFileId -> RetentionTime]
foreach (object[] row in rtQuery.List <object[]>())
{
var precursorId = (int)row[0];
var sampleFileId = (int)row[1];
var rt = Convert.ToDouble(row[2]);
if (!rtDictionary.ContainsKey(precursorId))
{
rtDictionary.Add(precursorId, new List <KeyValuePair <int, double> >());
}
rtDictionary[precursorId].Add(new KeyValuePair <int, double>(sampleFileId, rt));
}
var precursorQuery =
session.CreateQuery("SELECT P.Id, P.ModifiedSequence, P.Charge, P.TotalArea FROM " + typeof(Precursor) + // Not L10N
" P"); // Not L10N
var allTransitionAreas = ReadAllTransitionAreas(session);
var spectrumInfos = new List <ChromLibSpectrumInfo>();
foreach (object[] row in precursorQuery.List <object[]>())
{
var id = (int)row[0];
if (row[1] == null || row[2] == null)
{
continue; // Throw an error?
}
var modifiedSequence = new Target((string)row[1]);
var charge = (int)row[2]; // TODO(bspratt) generalize chromatogram libs to small mol
double totalArea = Convert.ToDouble(row[3]);
List <KeyValuePair <int, double> > retentionTimes;
var indexedRetentionTimes = new IndexedRetentionTimes();
if (rtDictionary.TryGetValue(id, out retentionTimes))
{
indexedRetentionTimes = new IndexedRetentionTimes(retentionTimes);
}
Target modSeqNormal;
try
{
modSeqNormal = SequenceMassCalc.NormalizeModifiedSequence(modifiedSequence);
}
catch (ArgumentException)
{
continue;
}
var libKey = new LibKey(modSeqNormal.Sequence, charge);
IList <SpectrumPeaksInfo.MI> transitionAreas;
allTransitionAreas.TryGetValue(id, out transitionAreas);
spectrumInfos.Add(new ChromLibSpectrumInfo(libKey, id, totalArea, indexedRetentionTimes, transitionAreas));
}
SetLibraryEntries(spectrumInfos);
var sampleFileQuery =
session.CreateQuery("SELECT Id, FilePath, SampleName, AcquiredTime, ModifiedTime, InstrumentIonizationType, " + // Not L10N
"InstrumentAnalyzer, InstrumentDetector FROM SampleFile"); // Not L10N
var sampleFiles = new List <ChromatogramLibrarySourceInfo>();
foreach (object[] row in sampleFileQuery.List <object[]>())
{
var id = (int)row[0];
if (row[1] == null || row[2] == null)
{
continue; // Throw an error?
}
var filePath = row[1].ToString();
var sampleName = row[2].ToString();
var acquiredTime = row[3] != null ? row[3].ToString() : string.Empty;
var modifiedTime = row[4] != null ? row[4].ToString() : string.Empty;
var instrumentIonizationType = row[5] != null ? row[5].ToString() : string.Empty;
var instrumentAnalyzer = row[6] != null ? row[6].ToString() : string.Empty;
var instrumentDetector = row[7] != null ? row[7].ToString() : string.Empty;
sampleFiles.Add(new ChromatogramLibrarySourceInfo(id, filePath, sampleName, acquiredTime, modifiedTime, instrumentIonizationType,
instrumentAnalyzer, instrumentDetector));
}
_librarySourceFiles = sampleFiles.ToArray();
loader.UpdateProgress(status.Complete());
return(true);
}
}
catch (Exception e)
{
Trace.TraceWarning(Resources.ChromatogramLibrary_LoadLibraryFromDatabase_Error_loading_chromatogram_library__0_, e);
return(false);
}
}
protected void Complete(Exception x)
{
lock (this)
{
ChromatogramCache result = null;
try
{
if (x == null && !_status.IsFinal)
{
long locationScanIds = 0, countBytesScanIds = 0;
if (_fs.Stream != null)
{
try
{
locationScanIds = _fs.Stream.Position;
countBytesScanIds = _fsScans.Stream.Position;
ChromatogramCache.WriteStructs(_fs.Stream,
_fsScans.Stream,
_fsPeaks.Stream,
_fsScores.Stream,
_listCachedFiles,
_listGroups,
_listTransitions,
_listTextIdBytes,
_listScoreTypes,
_scoreCount,
_peakCount);
_loader.StreamManager.Finish(_fs.Stream);
_fs.Stream = null;
// Allow cancelation right up to the final commit
if (!_loader.IsCanceled)
{
_fs.Commit(_destinationStream);
}
else
{
_loader.UpdateProgress(_status = _status.Cancel());
}
}
catch (Exception xWrite)
{
throw new IOException(TextUtil.LineSeparate(string.Format(Resources.ChromCacheWriter_Complete_Failure_attempting_to_write_the_file__0_, _fs.RealName), xWrite.Message));
}
}
if (!_status.IsCanceled)
{
// Create stream identifier, but do not open. The stream will be opened
// the first time the document uses it.
var readStream = _loader.StreamManager.CreatePooledStream(CachePath, false);
// DebugLog.Info("{0}. {1} - created", readStream.GlobalIndex, CachePath);
_fsPeaks.Stream.Seek(0, SeekOrigin.Begin);
_fsScores.Stream.Seek(0, SeekOrigin.Begin);
var rawData = new ChromatogramCache.RawData
{
FormatVersion = ChromatogramCache.FORMAT_VERSION_CACHE,
ChromCacheFiles = _listCachedFiles.ToArray(),
ChromatogramEntries = _listGroups.ToArray(),
ChromTransitions = _listTransitions.ToArray(),
ChromatogramPeaks = new BlockedArray <ChromPeak>(
count => ChromPeak.ReadArray(_fsPeaks.FileStream, count), _peakCount,
ChromPeak.SizeOf, ChromPeak.DEFAULT_BLOCK_SIZE),
ScoreTypes = _listScoreTypes.ToArray(),
Scores = new BlockedArray <float>(
count => PrimitiveArrays.Read <float>(_fsScores.FileStream, count), _scoreCount,
sizeof(float), ChromatogramCache.DEFAULT_SCORES_BLOCK_SIZE),
TextIdBytes = _listTextIdBytes.ToArray(),
LocationScanIds = locationScanIds,
CountBytesScanIds = countBytesScanIds,
};
result = new ChromatogramCache(CachePath, rawData, readStream);
_status = _status.Complete();
_loader.UpdateProgress(_status);
}
}
}
catch (Exception x2)
{
x = x2;
}
finally
{
Dispose();
}
try
{
_completed(result, x == null ? _status : _status.ChangeErrorException(x));
}
catch (Exception x2)
{
_completed(null, _status.ChangeErrorException(x2));
}
}
}
private bool LoadLibraryFromDatabase(ILoadMonitor loader)
{
try
{
var status = new ProgressStatus(
string.Format(Resources.ChromatogramLibrary_LoadLibraryFromDatabase_Reading_precursors_from__0_,
Name));
loader.UpdateProgress(status);
var libKeySourceFileDatas = new Dictionary <Tuple <string, int>, Dictionary <string, Tuple <double?, FileData> > >();
using (var cmd = new SQLiteCommand(_pooledSqliteConnection.Connection))
{
// From the "entries" table, read all of the peptides that were actually found
cmd.CommandText =
"SELECT PeptideModSeq, PrecursorCharge, SourceFile, Score, RTInSeconds, RTInSecondsStart, RTInSecondsStop FROM entries"; // Not L10N
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
if (loader.IsCanceled)
{
throw new OperationCanceledException();
}
var libKey = Tuple.Create(reader.GetString(0), Convert.ToInt32(reader.GetValue(1)));
// Tuple of filename, score, FileData
Dictionary <string, Tuple <double?, FileData> > dataByFilename;
if (!libKeySourceFileDatas.TryGetValue(libKey, out dataByFilename))
{
dataByFilename = new Dictionary <string, Tuple <double?, FileData> >();
libKeySourceFileDatas.Add(libKey, dataByFilename);
}
string fileName = reader.GetString(2);
if (dataByFilename.ContainsKey(fileName))
{
continue;
}
double score = -reader.GetDouble(3);
dataByFilename.Add(fileName, Tuple.Create((double?)score,
new FileData(reader.GetDouble(4) / 60,
new PeakBounds(reader.GetDouble(5) / 60, reader.GetDouble(6) / 60))));
}
}
// Also, read the PeptideQuants table in order to get peak boundaries for any peptide&sourcefiles that were
// not found in the Entries table.
cmd.CommandText =
"SELECT PeptideModSeq, PrecursorCharge, SourceFile, RTInSecondsStart, RTInSecondsStop from PeptideQuants"; // Not L10N
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var libKey = Tuple.Create(reader.GetString(0), Convert.ToInt32(reader.GetValue(1)));
// Tuple of filename, score, FileData
Dictionary <string, Tuple <double?, FileData> > dataByFilename;
if (!libKeySourceFileDatas.TryGetValue(libKey, out dataByFilename))
{
dataByFilename = new Dictionary <string, Tuple <double?, FileData> >();
libKeySourceFileDatas.Add(libKey, dataByFilename);
}
string fileName = reader.GetString(2);
if (dataByFilename.ContainsKey(fileName))
{
continue;
}
dataByFilename.Add(fileName,
Tuple.Create((double?)null,
new FileData(null, new PeakBounds(reader.GetDouble(3) / 60, reader.GetDouble(4) / 60))));
}
}
}
var sourceFiles = libKeySourceFileDatas
.SelectMany(entry => entry.Value.Keys)
.Distinct()
.ToArray();
Array.Sort(sourceFiles);
var sourceFileIds = sourceFiles.Select((file, index) => Tuple.Create(file, index))
.ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);
var spectrumInfos =
libKeySourceFileDatas.Select(entry => MakeSpectrumInfo(entry.Key.Item1, entry.Key.Item2, entry.Value, sourceFileIds));
SetLibraryEntries(spectrumInfos);
_sourceFiles = ImmutableList.ValueOf(sourceFiles);
loader.UpdateProgress(status.Complete());
return(true);
}
catch (Exception e)
{
Trace.TraceWarning(
Resources.ChromatogramLibrary_LoadLibraryFromDatabase_Error_loading_chromatogram_library__0_, e);
return(false);
}
}
protected void Complete(Exception x)
{
lock (this)
{
ChromatogramCache result = null;
try
{
if (x == null && !_status.IsFinal)
{
long locationScanIds = 0, countBytesScanIds = 0;
if (_fs.Stream != null)
{
locationScanIds = _fs.Stream.Position;
countBytesScanIds = _fsScans.Stream.Position;
ChromatogramCache.WriteStructs(_fs.Stream,
_fsScans.Stream,
_fsPeaks.Stream,
_fsScores.Stream,
_listCachedFiles,
_listGroups,
_listTransitions,
_listTextIdBytes,
_listScoreTypes,
_scoreCount,
_peakCount);
_loader.StreamManager.Finish(_fs.Stream);
_fs.Stream = null;
_fs.Commit(_destinationStream);
}
// Create stream identifier, but do not open. The stream will be opened
// the first time the document uses it.
var readStream = _loader.StreamManager.CreatePooledStream(CachePath, false);
_fsPeaks.Stream.Seek(0, SeekOrigin.Begin);
_fsScores.Stream.Seek(0, SeekOrigin.Begin);
var rawData = new ChromatogramCache.RawData
{
FormatVersion = ChromatogramCache.FORMAT_VERSION_CACHE,
ChromCacheFiles = _listCachedFiles.ToArray(),
ChromatogramEntries = _listGroups.ToArray(),
ChromTransitions = _listTransitions.ToArray(),
ChromatogramPeaks = new BlockedArray <ChromPeak>(
count => ChromPeak.ReadArray(_fsPeaks.FileStream.SafeFileHandle, count), _peakCount,
ChromPeak.SizeOf, ChromPeak.DEFAULT_BLOCK_SIZE),
ScoreTypes = _listScoreTypes.ToArray(),
Scores = new BlockedArray <float>(
count => PrimitiveArrays.Read <float>(_fsScores.FileStream, count), _scoreCount,
sizeof(float), ChromatogramCache.DEFAULT_SCORES_BLOCK_SIZE),
TextIdBytes = _listTextIdBytes.ToArray(),
LocationScanIds = locationScanIds,
CountBytesScanIds = countBytesScanIds,
};
result = new ChromatogramCache(CachePath, rawData, readStream);
_loader.UpdateProgress(_status.Complete());
}
}
catch (Exception x2)
{
x = x2;
}
finally
{
Dispose();
}
try
{
_completed(result, x);
}
catch (Exception x2)
{
_completed(null, x2);
}
}
}
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) { }
}
}
}
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 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 setSequences = new Dictionary <LibSeqKey, bool>(numSpectra);
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);
byte[] specSequence = new byte[1024];
byte[] specHeader = new byte[1024];
countHeader = (int)SpectrumCacheHeader.count * 4;
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
ReadComplete(stream, specHeader, countHeader);
int seqKeyHash = GetInt32(specHeader, ((int)SpectrumCacheHeader.seq_key_hash));
int seqKeyLength = GetInt32(specHeader, ((int)SpectrumCacheHeader.seq_key_length));
int charge = GetInt32(specHeader, ((int)SpectrumCacheHeader.charge));
if (charge == 0 || charge > TransitionGroup.MAX_PRECURSOR_CHARGE)
{
throw new InvalidDataException(Resources.XHunterLibrary_Load_Invalid_precursor_charge_found_File_may_be_corrupted);
}
float i2 = BitConverter.ToSingle(specHeader, ((int)SpectrumCacheHeader.i2) * 4);
long location = BitConverter.ToInt64(specHeader, ((int)SpectrumCacheHeader.location_lo) * 4);
int numPeaks = GetInt32(specHeader, ((int)SpectrumCacheHeader.num_peaks));
float expect = BitConverter.ToSingle(specHeader, ((int)SpectrumCacheHeader.expect) * 4);
int seqLength = GetInt32(specHeader, (int)SpectrumCacheHeader.seq_len);
// Read sequence information
ReadComplete(stream, specSequence, seqLength);
LibKey key = new LibKey(specSequence, 0, seqLength, charge);
libraryEntries[i] = new XHunterSpectrumInfo(key, i2, expect, (short)numPeaks, location);
if (seqKeyLength > 0)
{
LibSeqKey seqKey = new LibSeqKey(key, seqKeyHash, seqKeyLength);
setSequences.Add(seqKey, true);
}
}
// Checksum = checksum.ChecksumValue;
_libraryEntries = libraryEntries;
_setSequences = setSequences;
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 Load(ILoadMonitor loader)
{
ProgressStatus status =
new ProgressStatus(string.Format(Resources.BiblioSpecLibrary_Load_Loading__0__library,
Path.GetFileName(FilePath)));
loader.UpdateProgress(status);
long lenRead = 0;
// AdlerChecksum checksum = new AdlerChecksum();
try
{
// Use a buffered stream for initial read
BufferedStream stream = new BufferedStream(CreateStream(loader), 32 * 1024);
int countHeader = (int)LibHeaders.count * 4;
byte[] libHeader = new byte[countHeader];
if (stream.Read(libHeader, 0, countHeader) != countHeader)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_library_header_File_may_be_corrupted);
}
lenRead += countHeader;
// Check the first byte of the primary version number to determine
// whether the format is little- or big-endian. Little-endian will
// have the version number in this byte, while big-endian will have zero.
if (libHeader[(int)LibHeaders.version1 * 4] == 0)
{
_bigEndian = true;
}
int numSpectra = GetInt32(libHeader, (int)LibHeaders.num_spectra);
var dictLibrary = new Dictionary <LibKey, BiblioSpectrumInfo>(numSpectra);
var setSequences = new HashSet <LibSeqKey>();
string revStr = string.Format("{0}.{1}", // Not L10N
GetInt32(libHeader, (int)LibHeaders.version1),
GetInt32(libHeader, (int)LibHeaders.version2));
Revision = float.Parse(revStr, CultureInfo.InvariantCulture);
// checksum.MakeForBuff(libHeader, AdlerChecksum.ADLER_START);
countHeader = (int)SpectrumHeaders.count * 4;
byte[] specHeader = new byte[1024];
byte[] specSequence = new byte[1024];
for (int i = 0; i < numSpectra; i++)
{
int percent = i * 100 / 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
int bytesRead = stream.Read(specHeader, 0, countHeader);
if (bytesRead != countHeader)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_header_File_may_be_corrupted);
}
// If this is the first header, and the sequence length is zero,
// then this is a Linux format library. Switch to linux format,
// and start over.
if (i == 0 && GetInt32(specHeader, (int)SpectrumHeaders.seq_len) == 0)
{
_linuxFormat = true;
stream.Seek(lenRead, SeekOrigin.Begin);
// Re-ead spectrum header
countHeader = (int)SpectrumHeadersLinux.count * 4;
bytesRead = stream.Read(specHeader, 0, countHeader);
if (bytesRead != countHeader)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_header_File_may_be_corrupted);
}
}
lenRead += bytesRead;
// checksum.MakeForBuff(specHeader, checksum.ChecksumValue);
int charge = GetInt32(specHeader, (int)SpectrumHeaders.charge);
if (charge > TransitionGroup.MAX_PRECURSOR_CHARGE)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Invalid_precursor_charge_found_File_may_be_corrupted);
}
int numPeaks = GetInt32(specHeader, (int)SpectrumHeaders.num_peaks);
int seqLength = GetInt32(specHeader, (_linuxFormat ?
(int)SpectrumHeadersLinux.seq_len : (int)SpectrumHeaders.seq_len));
int copies = GetInt32(specHeader, (_linuxFormat ?
(int)SpectrumHeadersLinux.copies : (int)SpectrumHeaders.copies));
// Read sequence information
int countSeq = (seqLength + 1) * 2;
if (stream.Read(specSequence, 0, countSeq) != countSeq)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_sequence_File_may_be_corrupted);
}
lenRead += countSeq;
// checksum.MakeForBuff(specSequence, checksum.ChecksumValue);
// Store in dictionary
if (IsUnmodified(specSequence, seqLength + 1, seqLength))
{
// These libraries should not have duplicates, but just in case.
// CONSIDER: Emit error about redundancy?
// These legacy libraries assume [+57.0] modified Cysteine
LibKey key = new LibKey(GetCModified(specSequence, ref seqLength), 0, seqLength, charge);
if (!dictLibrary.ContainsKey(key))
{
dictLibrary.Add(key, new BiblioSpectrumInfo((short)copies, (short)numPeaks, lenRead));
}
setSequences.Add(new LibSeqKey(key));
}
// Read over peaks
int countPeaks = 2 * sizeof(Single) * numPeaks;
stream.Seek(countPeaks, SeekOrigin.Current); // Skip spectrum
lenRead += countPeaks;
// checksum.MakeForBuff(specPeaks, checksum.ChecksumValue);
}
// Checksum = checksum.ChecksumValue;
_dictLibrary = dictLibrary;
_setSequences = setSequences;
loader.UpdateProgress(status.Complete());
return(true);
}
catch (InvalidDataException x)
{
loader.UpdateProgress(status.ChangeErrorException(x));
return(false);
}
catch (IOException x)
{
loader.UpdateProgress(status.ChangeErrorException(x));
return(false);
}
catch (Exception x)
{
x = new Exception(string.Format(Resources.BiblioSpecLibrary_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 Load(ILoadMonitor loader)
{
ProgressStatus status =
new ProgressStatus(string.Format(Resources.BiblioSpecLibrary_Load_Loading__0__library,
Path.GetFileName(FilePath)));
loader.UpdateProgress(status);
long lenRead = 0;
// AdlerChecksum checksum = new AdlerChecksum();
try
{
// Use a buffered stream for initial read
BufferedStream stream = new BufferedStream(CreateStream(loader), 32 * 1024);
int countHeader = (int) LibHeaders.count*4;
byte[] libHeader = new byte[countHeader];
if (stream.Read(libHeader, 0, countHeader) != countHeader)
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_library_header_File_may_be_corrupted);
lenRead += countHeader;
// Check the first byte of the primary version number to determine
// whether the format is little- or big-endian. Little-endian will
// have the version number in this byte, while big-endian will have zero.
if (libHeader[(int) LibHeaders.version1 * 4] == 0)
_bigEndian = true;
int numSpectra = GetInt32(libHeader, (int) LibHeaders.num_spectra);
var dictLibrary = new Dictionary<LibKey, BiblioSpectrumInfo>(numSpectra);
var setSequences = new HashSet<LibSeqKey>();
string revStr = string.Format("{0}.{1}", // Not L10N
GetInt32(libHeader, (int) LibHeaders.version1),
GetInt32(libHeader, (int) LibHeaders.version2));
Revision = float.Parse(revStr, CultureInfo.InvariantCulture);
// checksum.MakeForBuff(libHeader, AdlerChecksum.ADLER_START);
countHeader = (int) SpectrumHeaders.count*4;
byte[] specHeader = new byte[1024];
byte[] specSequence = new byte[1024];
for (int i = 0; i < numSpectra; i++)
{
int percent = i * 100 / 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
int bytesRead = stream.Read(specHeader, 0, countHeader);
if (bytesRead != countHeader)
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_header_File_may_be_corrupted);
// If this is the first header, and the sequence length is zero,
// then this is a Linux format library. Switch to linux format,
// and start over.
if (i == 0 && GetInt32(specHeader, (int)SpectrumHeaders.seq_len) == 0)
{
_linuxFormat = true;
stream.Seek(lenRead, SeekOrigin.Begin);
// Re-ead spectrum header
countHeader = (int)SpectrumHeadersLinux.count * 4;
bytesRead = stream.Read(specHeader, 0, countHeader);
if (bytesRead != countHeader)
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_header_File_may_be_corrupted);
}
lenRead += bytesRead;
// checksum.MakeForBuff(specHeader, checksum.ChecksumValue);
int charge = GetInt32(specHeader, (int)SpectrumHeaders.charge);
if (charge > TransitionGroup.MAX_PRECURSOR_CHARGE)
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Invalid_precursor_charge_found_File_may_be_corrupted);
int numPeaks = GetInt32(specHeader, (int)SpectrumHeaders.num_peaks);
int seqLength = GetInt32(specHeader, (_linuxFormat ?
(int)SpectrumHeadersLinux.seq_len : (int)SpectrumHeaders.seq_len));
int copies = GetInt32(specHeader, (_linuxFormat ?
(int)SpectrumHeadersLinux.copies : (int)SpectrumHeaders.copies));
// Read sequence information
int countSeq = (seqLength + 1)*2;
if (stream.Read(specSequence, 0, countSeq) != countSeq)
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_sequence_File_may_be_corrupted);
lenRead += countSeq;
// checksum.MakeForBuff(specSequence, checksum.ChecksumValue);
// Store in dictionary
if (IsUnmodified(specSequence, seqLength + 1, seqLength))
{
// These libraries should not have duplicates, but just in case.
// CONSIDER: Emit error about redundancy?
// These legacy libraries assume [+57.0] modified Cysteine
LibKey key = new LibKey(GetCModified(specSequence, ref seqLength), 0, seqLength, charge);
if (!dictLibrary.ContainsKey(key))
dictLibrary.Add(key, new BiblioSpectrumInfo((short)copies, (short)numPeaks, lenRead));
setSequences.Add(new LibSeqKey(key));
}
// Read over peaks
int countPeaks = 2*sizeof(Single)*numPeaks;
stream.Seek(countPeaks, SeekOrigin.Current); // Skip spectrum
lenRead += countPeaks;
// checksum.MakeForBuff(specPeaks, checksum.ChecksumValue);
}
// Checksum = checksum.ChecksumValue;
_dictLibrary = dictLibrary;
_setSequences = setSequences;
loader.UpdateProgress(status.Complete());
return true;
}
catch (InvalidDataException x)
{
loader.UpdateProgress(status.ChangeErrorException(x));
return false;
}
catch (IOException x)
{
loader.UpdateProgress(status.ChangeErrorException(x));
return false;
}
catch (Exception x)
{
x = new Exception(string.Format(Resources.BiblioSpecLibrary_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) {}
}
}
}