public RemoteChromDataProvider(SrmDocument document, IRetentionTimePredictor retentionTimePredictor, ChromFileInfo chromFileInfo, ProgressStatus progressStatus, int startPercent,
int endPercent, ILoadMonitor loader)
: base(chromFileInfo, progressStatus, startPercent, endPercent, loader)
{
_document = document;
ChorusUrl chorusUrl = (ChorusUrl)chromFileInfo.FilePath;
_chorusAccount = chorusUrl.FindChorusAccount(Settings.Default.ChorusAccountList);
var chromatogramRequestProviders = new List<ChromatogramRequestProvider>();
foreach (bool firstPass in new[] {true, false})
{
if (null == retentionTimePredictor && !firstPass)
{
continue;
}
var chromatogramRequestProvider = new ChromatogramRequestProvider(document, chorusUrl,
retentionTimePredictor, firstPass);
if (0 == chromatogramRequestProvider.ChromKeys.Count)
{
continue;
}
chromatogramRequestProviders.Add(chromatogramRequestProvider);
}
_chromatogramRequestProviders = chromatogramRequestProviders.ToArray();
_chromTaskLists = new ChromTaskList[_chromatogramRequestProviders.Length];
}
private Stream CreateStream(ILoadMonitor loader)
{
if (_readStream == null)
{
_readStream = loader.StreamManager.CreatePooledStream(FilePath, false);
}
return(ReadStream.Stream);
}
public ChromCacheJoiner(string cachePath, IPooledStream streamDest,
IList <string> cacheFilePaths, ILoadMonitor loader, ProgressStatus status,
Action <ChromatogramCache, IProgressStatus> completed)
: base(cachePath, loader, status, completed)
{
_destinationStream = streamDest;
CacheFilePaths = cacheFilePaths;
}
public ChromCacheJoiner(string cachePath, IPooledStream streamDest,
IList<string> cacheFilePaths, ILoadMonitor loader, ProgressStatus status,
Action<ChromatogramCache, Exception> completed)
: base(cachePath, loader, status, completed)
{
_destinationStream = streamDest;
CacheFilePaths = cacheFilePaths;
}
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 static XHunterLibrary Load(XHunterLibSpec spec, ILoadMonitor loader)
{
var library = new XHunterLibrary(spec);
if (library.Load(loader))
{
return(library);
}
return(null);
}
public ChromCacheJoiner(string cachePath, IPooledStream streamDest,
IList <string> cacheFilePaths, ILoadMonitor loader, ProgressStatus status,
Action <ChromatogramCache, IProgressStatus> completed,
bool assumeNegativeChargeInPreV11Caches)
: base(cachePath, loader, status, completed)
{
_destinationStream = streamDest;
CacheFilePaths = cacheFilePaths;
_assumeNegativeChargeInPreV11Caches = assumeNegativeChargeInPreV11Caches; // Deal with older cache formats where we did not record polarity
}
protected ChromCacheWriter(string cachePath, ILoadMonitor loader, ProgressStatus status,
Action<ChromatogramCache, Exception> completed)
{
CachePath = cachePath;
_fs = new FileSaver(CachePath);
_fsScans = new FileSaver(CachePath + ChromatogramCache.SCANS_EXT, true);
_fsPeaks = new FileSaver(CachePath + ChromatogramCache.PEAKS_EXT, true);
_fsScores = new FileSaver(CachePath + ChromatogramCache.SCORES_EXT, true);
_loader = loader;
_status = status;
_completed = completed;
}
protected ChromCacheWriter(string cachePath, ILoadMonitor loader, IProgressStatus status,
Action <ChromatogramCache, IProgressStatus> completed)
{
CachePath = cachePath;
_fs = new FileSaver(CachePath);
_fsScans = new FileSaver(CachePath + ChromatogramCache.SCANS_EXT, true);
_fsPeaks = new FileSaver(CachePath + ChromatogramCache.PEAKS_EXT, true);
_fsScores = new FileSaver(CachePath + ChromatogramCache.SCORES_EXT, true);
_loader = loader;
_status = status;
_completed = completed;
}
public static EncyclopeDiaLibrary Load(EncyclopeDiaSpec spec, ILoadMonitor loader)
{
if (File.Exists(spec.FilePath) && new FileInfo(spec.FilePath).Length > 0)
{
var library = new EncyclopeDiaLibrary(spec, loader.StreamManager);
if (library.Load(loader))
{
return(library);
}
}
return(null);
}
private bool Load(ILoadMonitor loader)
{
if (LoadFromCache(loader))
{
return(true);
}
if (LoadLibraryFromDatabase(loader))
{
WriteCache(loader);
return(true);
}
return(false);
}
public static BiblioSpecLibrary Load(BiblioSpecLibSpec spec, ILoadMonitor loader)
{
var library = new BiblioSpecLibrary(spec)
{
FilePath = spec.FilePath
};
if (library.Load(loader))
{
return(library);
}
return(null);
}
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 static Library CreateLibraryFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, Action <IStreamManager, Library> write)
{
streamManager.TextFiles[PATH_NIST_LIB] = nistText;
var librarySpec = new NistLibSpec("Temporary (NIST)", PATH_NIST_LIB);
Library libNist = librarySpec.LoadLibrary(loader);
Assert.IsNotNull(libNist);
write(streamManager, libNist);
streamManager.TextFiles.Remove(PATH_NIST_LIB);
streamManager.Delete(PATH_NIST_LIB_CACHE);
return(libNist);
}
public ChorusResponseChromDataProvider(SrmDocument document, ChromFileInfo chromFileInfo, ProgressStatus progressStatus, int startPercent,
int endPercent, ILoadMonitor loader)
: base(chromFileInfo, progressStatus, startPercent, endPercent, loader)
{
ChromatogramCache.RawData rawData;
MsDataFilePath msDataFilePath = (MsDataFilePath) chromFileInfo.FilePath;
IPooledStream stream = loader.StreamManager.CreatePooledStream(msDataFilePath.FilePath, false);
ChromatogramCache.LoadStructs(stream.Stream, out rawData);
var chromCacheFile = rawData.ChromCacheFiles[0];
rawData.ChromCacheFiles = new[]
{
new ChromCachedFile(chromFileInfo.FilePath, chromCacheFile.Flags, chromCacheFile.FileWriteTime,
chromCacheFile.RunStartTime, chromCacheFile.MaxRetentionTime, chromCacheFile.MaxIntensity,
chromCacheFile.InstrumentInfoList),
};
var cache = new ChromatogramCache("cachePath", rawData, stream); // Not L10N
_cachedChromatogramDataProvider = new CachedChromatogramDataProvider(cache, document,
chromFileInfo.FilePath, chromFileInfo, null, progressStatus, startPercent, endPercent, loader);
}
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);
}
}
private bool LoadFromCache(ILoadMonitor loadMonitor, ProgressStatus status)
{
if (!loadMonitor.StreamManager.IsCached(FilePath, CachePath))
{
return(false);
}
try
{
using (var stream = loadMonitor.StreamManager.CreateStream(CachePath, FileMode.Open, true))
{
var serializer = new Serializer(this, stream);
serializer.Read();
return(true);
}
}
catch (Exception exception)
{
Trace.TraceWarning(Resources.ChromatogramLibrary_LoadFromCache_Exception_reading_cache__0_, exception);
return(false);
}
}
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);
}
public ChorusResponseChromDataProvider(SrmDocument document, ChromFileInfo chromFileInfo, IProgressStatus progressStatus, int startPercent,
int endPercent, ILoadMonitor loader) : base(chromFileInfo, progressStatus, startPercent, endPercent, loader)
{
ChromatogramCache.RawData rawData;
MsDataFilePath msDataFilePath = (MsDataFilePath)chromFileInfo.FilePath;
IPooledStream stream = loader.StreamManager.CreatePooledStream(msDataFilePath.FilePath, false);
ChromatogramCache.LoadStructs(stream.Stream, out rawData);
var chromCacheFile = rawData.ChromCacheFiles[0];
rawData.ChromCacheFiles = new[]
{
new ChromCachedFile(chromFileInfo.FilePath, chromCacheFile.Flags, chromCacheFile.FileWriteTime,
chromCacheFile.RunStartTime, chromCacheFile.MaxRetentionTime, chromCacheFile.MaxIntensity,
chromCacheFile.InstrumentInfoList),
};
var cache = new ChromatogramCache("cachePath", rawData, stream); // Not L10N
_cachedChromatogramDataProvider = new CachedChromatogramDataProvider(cache, document,
chromFileInfo.FilePath, chromFileInfo, null, progressStatus, startPercent, endPercent, loader);
}
public CachedChromatogramDataProvider(ChromatogramCache cache,
SrmDocument document,
MsDataFileUri dataFilePath,
ChromFileInfo fileInfo,
bool? singleMatchMz,
ProgressStatus status,
int startPercent,
int endPercent,
ILoadMonitor loader)
: base(fileInfo, status, startPercent, endPercent, loader)
{
_cache = cache;
_fileIndex = cache.CachedFiles.IndexOf(f => Equals(f.FilePath, dataFilePath));
_chromKeyIndices = cache.GetChromKeys(dataFilePath).OrderBy(v => v.LocationPoints).ToArray();
_cache.GetStatusDimensions(dataFilePath, out _maxRetentionTime, out _maxIntensity);
_singleMatchMz = singleMatchMz.HasValue
? singleMatchMz.Value
// Unfortunately, before the single matching status was
// written into the cache file, we can only guess about its
// status based on the overall document settings
: document.Settings.TransitionSettings.FullScan.IsEnabled;
}
public CachedChromatogramDataProvider(ChromatogramCache cache,
SrmDocument document,
MsDataFileUri dataFilePath,
ChromFileInfo fileInfo,
bool?singleMatchMz,
ProgressStatus status,
int startPercent,
int endPercent,
ILoadMonitor loader)
: base(fileInfo, status, startPercent, endPercent, loader)
{
_cache = cache;
_fileIndex = cache.CachedFiles.IndexOf(f => Equals(f.FilePath, dataFilePath));
_chromKeyIndices = cache.GetChromKeys(dataFilePath).OrderBy(v => v.LocationPoints).ToArray();
_cache.GetStatusDimensions(dataFilePath, out _maxRetentionTime, out _maxIntensity);
_singleMatchMz = singleMatchMz.HasValue
? singleMatchMz.Value
// Unfortunately, before the single matching status was
// written into the cache file, we can only guess about its
// status based on the overall document settings
: document.Settings.TransitionSettings.FullScan.IsEnabled;
}
public CachedChromatogramDataProvider(ChromatogramCache cache,
SrmDocument document,
MsDataFileUri dataFilePath,
ChromFileInfo fileInfo,
bool?singleMatchMz,
IProgressStatus status,
int startPercent,
int endPercent,
ILoadMonitor loader)
: base(fileInfo, status, startPercent, endPercent, loader)
{
// Deal with older cache formats where we did not record chromatogram polarity
var assumeNegativeChargesInPreV11Caches = document.MoleculeTransitionGroups.All(p => p.PrecursorMz.IsNegative);
// Need a newly loaded copy to allow for concurrent loading for multiple cached files
_cache = ChromatogramCache.Load(cache.CachePath, new ProgressStatus(), loader, assumeNegativeChargesInPreV11Caches);
_fileIndex = cache.CachedFiles.IndexOf(f => Equals(f.FilePath, dataFilePath));
_chromKeyIndices = cache.GetChromKeys(dataFilePath).OrderBy(v => v.LocationPoints).ToArray();
foreach (var c in _chromKeyIndices.Where(i => i.Key.Precursor != 0))
{
if (c.Key.Precursor.IsNegative)
{
_sourceHasNegativePolarityData = true;
}
else
{
_sourceHasPositivePolarityData = true;
}
}
_cache.GetStatusDimensions(dataFilePath, out _maxRetentionTime, out _maxIntensity);
_singleMatchMz = singleMatchMz.HasValue
? singleMatchMz.Value
// Unfortunately, before the single matching status was
// written into the cache file, we can only guess about its
// status based on the overall document settings
: document.Settings.TransitionSettings.FullScan.IsEnabled;
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return(SpectrastLibrary.Load(this, loader));
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return(ChromatogramLibrary.LoadFromDatabase(this, loader));
}
private Stream CreateStream(ILoadMonitor loader)
{
if (_readStream == null)
_readStream = loader.StreamManager.CreatePooledStream(FilePath, false);
return ReadStream.Stream;
}
public static SpectrastLibrary Load(LibrarySpec spec, ILoadMonitor loader)
{
return((SpectrastLibrary)Load(spec, new SpectrastLibrary(spec), loader));
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return(XHunterLibrary.Load(this, loader));
}
// 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) {}
}
}
}
public static SpectrastLibrary Load(LibrarySpec spec, ILoadMonitor loader)
{
return (SpectrastLibrary)Load(spec, new SpectrastLibrary(spec), loader);
}
// 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 Library CreateBiblioFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return(CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => BiblioSpecLibrary.Write(sm, PATH_BIBLIOSPEC_LIB, lib)));
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return SpectrastLibrary.Load(this, loader);
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, bool lowIntensity)
{
return(CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => XHunterLibrary.Write(sm, PATH_HUNTER_LIB, lib, lowIntensity)));
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return(CreateHunterFile(streamManager, loader, nistText, false));
}
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());
}
}
public static Library CreateBiblioFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => BiblioSpecLibrary.Write(sm, PATH_BIBLIOSPEC_LIB, lib));
}
private static Library CreateLibraryFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, Action<IStreamManager, Library> write)
{
streamManager.TextFiles[PATH_NIST_LIB] = nistText;
var librarySpec = new NistLibSpec("Temporary (NIST)", PATH_NIST_LIB);
Library libNist = librarySpec.LoadLibrary(loader);
Assert.IsNotNull(libNist);
write(streamManager, libNist);
streamManager.TextFiles.Remove(PATH_NIST_LIB);
streamManager.Delete(PATH_NIST_LIB_CACHE);
return libNist;
}
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 static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, bool lowIntensity)
{
return CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => XHunterLibrary.Write(sm, PATH_HUNTER_LIB, lib, lowIntensity));
}
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) { }
}
}
}
public static void SetLoadMonitor(ILoadMonitor loadMon)
{
_loadMonitor = loadMon;
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return BiblioSpecLibrary.Load(this, loader);
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return CreateHunterFile(streamManager, loader, nistText, false);
}
// 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) {}
}
}
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return(BiblioSpecLibrary.Load(this, loader));
}
public override Library LoadLibrary(ILoadMonitor loader)
{
return ChromatogramLibrary.LoadFromDatabase(this, loader);
}
public static BiblioSpecLibrary Load(BiblioSpecLibSpec spec, ILoadMonitor loader)
{
var library = new BiblioSpecLibrary(spec) { FilePath = spec.FilePath };
if (library.Load(loader))
return library;
return null;
}
