public void AddAlignment(AlignmentKey alignmentKey, RetentionTimeAlignment alignmentValue)
{
_alignments = ImmutableSortedList.FromValues(
_alignments.Concat(new[]
{
new KeyValuePair<AlignmentKey, RetentionTimeAlignment>(alignmentKey, alignmentValue)
}));
}
public ReplicateSummaries(SrmDocument document)
{
Document = document;
int replicateCount = 0;
if (Document.Settings.HasResults)
{
replicateCount = Document.Settings.MeasuredResults.Chromatograms.Count;
}
_allTotalAreas = new ImmutableSortedList<IsotopeLabelType, double>[replicateCount];
}
public void MergeFrom(RetentionTimeAlignments retentionTimeAlignments)
{
var newAlignments = new List<KeyValuePair<AlignmentKey, RetentionTimeAlignment>>();
foreach (var pair in retentionTimeAlignments._alignments)
{
if (_alignments.ContainsKey(pair.Key))
{
continue;
}
if (Equals(GetRetentionTimes(pair.Key.FromId), retentionTimeAlignments.GetRetentionTimes(pair.Key.FromId))
&& Equals(GetRetentionTimes(pair.Key.ToId), retentionTimeAlignments.GetRetentionTimes(pair.Key.ToId)))
{
newAlignments.Add(pair);
}
}
if (newAlignments.Count == 0)
{
return;
}
_alignments = ImmutableSortedList.FromValues(_alignments.Concat(newAlignments));
}
public PeptideFormatter ChangeLinkedPeptides(
ImmutableSortedList <ModificationSite, PeptideFormatter> linkedPeptides)
{
return(ChangeProp(ImClone(this), im => im.LinkedPeptides = linkedPeptides));
}
public WorkspaceData LoadChanges(WorkspaceData savedData, IDictionary <long, bool> requestedPeptideAnalyses)
{
var workspaceData = savedData;
lock (_eventWaitHandle)
{
if (!_isRunning)
{
return(null);
}
}
var peptides = ToMutableDictionary(workspaceData.Peptides);
var msDataFiles = ToMutableDictionary(workspaceData.MsDataFiles);
var peptideAnalyses = ToMutableDictionary(workspaceData.PeptideAnalyses);
using (var session = _workspace.OpenSession())
{
var changedPeptideIds = new HashSet <long>();
var changedDataFileIds = new HashSet <long>();
var changedPeptideAnalysisIds = new HashSet <long>();
bool workspaceChanged = false;
if (workspaceData.LastChangeLogId.HasValue)
{
long lastChangeLogId = workspaceData.LastChangeLogId.Value;
var changeLogs = session.CreateCriteria <DbChangeLog>()
.Add(Restrictions.Gt("Id", workspaceData.LastChangeLogId))
.List <DbChangeLog>();
foreach (var dbChangeLog in changeLogs)
{
if (dbChangeLog.PeptideId.HasValue)
{
changedPeptideIds.Add(dbChangeLog.PeptideId.Value);
peptides.Remove(dbChangeLog.PeptideId.Value);
}
if (dbChangeLog.MsDataFileId.HasValue)
{
changedDataFileIds.Add(dbChangeLog.MsDataFileId.Value);
msDataFiles.Remove(dbChangeLog.MsDataFileId.Value);
}
if (dbChangeLog.PeptideAnalysisId.HasValue)
{
changedPeptideAnalysisIds.Add(dbChangeLog.PeptideAnalysisId.Value);
peptideAnalyses.Remove(dbChangeLog.PeptideAnalysisId.Value);
}
if (dbChangeLog.WorkspaceId.HasValue)
{
workspaceChanged = true;
}
lastChangeLogId = Math.Max(lastChangeLogId, dbChangeLog.GetId());
}
workspaceData = workspaceData.SetLastChangeLogId(lastChangeLogId);
}
else
{
workspaceChanged = true;
long lastChangeLogId = (long?)session.CreateQuery("SELECT Max(T.Id) FROM " + typeof(DbChangeLog) + " T")
.UniqueResult() ?? 0;
var dbWorkspace = session.CreateCriteria <DbWorkspace>().UniqueResult <DbWorkspace>();
workspaceData = workspaceData
.SetLastChangeLogId(lastChangeLogId)
.SetDbWorkspaceId(dbWorkspace.Id);
}
if (workspaceChanged)
{
var settings =
session.CreateCriteria <DbSetting>()
.List <DbSetting>()
.ToDictionary(dbSetting => dbSetting.Name, dbSetting => dbSetting.Value);
var tracerDefs =
session.CreateCriteria <DbTracerDef>()
.List <DbTracerDef>()
.ToDictionary(dbTracerDef => dbTracerDef.Name,
dbTracerDef => new TracerDefData(dbTracerDef));
var modifications =
session.CreateCriteria <DbModification>()
.List <DbModification>()
.ToDictionary(dbModification => dbModification.Symbol,
dbModification => dbModification.DeltaMass);
workspaceData = workspaceData
.SetSettings(ImmutableSortedList.FromValues(settings))
.SetTracerDefs(ImmutableSortedList.FromValues(tracerDefs))
.SetModifications(ImmutableSortedList.FromValues(modifications));
}
foreach (var dbPeptide in EntitiesWithIdGreaterThanOrOneOf <DbPeptide>(session, GetLastId(savedData.Peptides), changedPeptideIds))
{
peptides.Add(dbPeptide.GetId(), new PeptideData(dbPeptide));
}
workspaceData = workspaceData.SetPeptides(ImmutableSortedList.FromValues(peptides));
// Load the MSDataFiles
var dataFileIdPredicate = new IdPredicate(GetLastId(savedData.MsDataFiles), changedDataFileIds);
var psmsByDataFileId = session.CreateQuery("FROM " + typeof(DbPeptideSpectrumMatch) + " M WHERE " +
dataFileIdPredicate.GetSql("M.MsDataFile.Id")).List <DbPeptideSpectrumMatch>().ToLookup(psm => psm.MsDataFile.Id);
foreach (var dbMsDataFile in EntitiesWithIdGreaterThanOrOneOf <DbMsDataFile>(session, GetLastId(savedData.MsDataFiles), changedDataFileIds))
{
var msDataFileData = new MsDataFileData(dbMsDataFile);
var psmTimes = psmsByDataFileId[dbMsDataFile.GetId()].ToLookup(psm => psm.ModifiedSequence, psm => psm.RetentionTime);
msDataFileData = msDataFileData.SetRetentionTimesByModifiedSequence(
psmTimes.Select(grouping => new KeyValuePair <string, double>(grouping.Key, grouping.Min())));
msDataFiles.Add(dbMsDataFile.GetId(), msDataFileData);
}
workspaceData = workspaceData.SetMsDataFiles(ImmutableSortedList.FromValues(msDataFiles));
var idsToSnapshot = new HashSet <long>(changedPeptideAnalysisIds);
var chromatogramsToSnapshot = new HashSet <long>();
if (null != requestedPeptideAnalyses)
{
foreach (var pair in requestedPeptideAnalyses)
{
PeptideAnalysisData existing;
if (peptideAnalyses.TryGetValue(pair.Key, out existing))
{
if (pair.Value)
{
if (existing.ChromatogramsWereLoaded)
{
continue;
}
}
else
{
peptideAnalyses[pair.Key] = existing.UnloadChromatograms();
continue;
}
}
idsToSnapshot.Add(pair.Key);
if (pair.Value)
{
chromatogramsToSnapshot.Add(pair.Key);
}
}
}
var loadedPeptideAnalyses = PeptideAnalysisSnapshot.Query(session,
new IdPredicate(GetLastId(workspaceData.PeptideAnalyses) + 1, idsToSnapshot),
new IdPredicate(null, chromatogramsToSnapshot));
foreach (var entry in loadedPeptideAnalyses)
{
peptideAnalyses[entry.Key] = entry.Value;
}
workspaceData = workspaceData.SetPeptideAnalyses(ImmutableSortedList.FromValues(peptideAnalyses));
}
return(workspaceData);
}
public PeptideAnalysisData SetFileAnalyses(ImmutableSortedList<long, PeptideFileAnalysisData> value)
{
return new PeptideAnalysisData(this) {FileAnalyses = value};
}
protected abstract WorkspaceData SetData(WorkspaceData workspaceData, ImmutableSortedList <TKey, TData> data);
protected override ImmutableSortedList <long, PeptideFileAnalysis> CreateEntityList()
{
return(ImmutableSortedList.FromValues(
PeptideAnalysis.Data.FileAnalyses.Select(
pair => new KeyValuePair <long, PeptideFileAnalysis>(pair.Key, new PeptideFileAnalysis(PeptideAnalysis, pair.Key, pair.Value)))));
}
public WorkspaceData SetModifications(ImmutableSortedList<string, double> value)
{
return new WorkspaceData(this){Modifications = value};
}
public static T FromDict(IDictionary <string, int> dict)
{
return(new T {
Dictionary = ImmutableSortedList.FromValues(dict)
});
}
public static T FromDict(ImmutableSortedList <string, int> dict)
{
return(new T {
Dictionary = dict
});
}
// Handle formulae which may contain subtractions, as is deprotonation description ie C12H8O2-H (=C12H7O2) or even C12H8O2-H2O (=C12H6O)
public static T ParseExpression(String formula)
{
return(new T {
Dictionary = ImmutableSortedList.FromValues(ParseExpressionToDictionary(formula))
});
}
protected IDictionary <ResultKey, TResult> MakeChromInfoResultsMap <TChromInfo, TResult>(
Results <TChromInfo> results, Func <ResultFile, TResult> newResultFunc) where TChromInfo : ChromInfo
{
if (results == null)
{
return(ImmutableSortedList <ResultKey, TResult> .EMPTY.AsDictionary());
}
var replicates = DataSchema.ReplicateList;
var resultFiles = DataSchema.ResultFileList;
if (replicates.Count == results.Count && results.All(r => r.Count == 1 && r[0] != null))
{
// If every replicate has exactly one result, then we can reuse the keys in "DataSchema.ReplicateList".
var newValues = new List <TResult>(replicates.Count);
for (int replicateIndex = 0; replicateIndex < replicates.Count; replicateIndex++)
{
var chromInfo = results[replicateIndex][0];
var optStep = ResultFile.GetOptStep(chromInfo);
ResultFile resultFile = null;
if (optStep == 0)
{
resultFiles.TryGetValue(new ResultFileKey(replicateIndex, chromInfo.FileId, optStep), out resultFile);
}
if (resultFile == null)
{
resultFile = new ResultFile(replicates.Values[replicateIndex], chromInfo.FileId, optStep);
}
newValues.Add(newResultFunc(resultFile));
}
return(replicates.ReplaceValues(newValues).AsDictionary());
}
var newEntries = new List <KeyValuePair <ResultKey, TResult> >();
for (int replicateIndex = 0; replicateIndex < results.Count; replicateIndex++)
{
var replicate = new Replicate(DataSchema, replicateIndex);
var files = results[replicateIndex];
for (int fileIndex = 0; fileIndex < files.Count; fileIndex++)
{
var chromInfo = files[fileIndex];
if (null == chromInfo)
{
continue;
}
var key = fileIndex == 0 ? replicates.Keys[replicateIndex] : new ResultKey(replicate, fileIndex);
int optStep = ResultFile.GetOptStep(chromInfo);
ResultFile resultFile = null;
if (optStep == 0)
{
resultFiles.TryGetValue(new ResultFileKey(replicateIndex, chromInfo.FileId, optStep), out resultFile);
}
if (resultFile == null)
{
resultFile = new ResultFile(replicates.Values[replicateIndex], chromInfo.FileId, optStep);
}
newEntries.Add(new KeyValuePair <ResultKey, TResult>(key, newResultFunc(resultFile)));
}
}
return(ImmutableSortedList <ResultKey, TResult> .FromValues(newEntries, Comparer <ResultKey> .Default)
.AsDictionary());
}
public void SetData(WorkspaceData workspaceData)
{
var dataFileIds =
_alignments.Keys.Select(key => key.FromId)
.Concat(_alignments.Keys.Select(key => key.ToId))
.Distinct()
.ToArray();
var changedDataFileIds = new HashSet<long>();
foreach (var dataFileId in dataFileIds)
{
if (!Equals(GetRetentionTimes(dataFileId), GetRetentionTimes(workspaceData, dataFileId)))
{
changedDataFileIds.Add(dataFileId);
}
}
if (changedDataFileIds.Count > 0)
{
_alignments = ImmutableSortedList.FromValues(
_alignments.Where(pair
=> !changedDataFileIds.Contains(pair.Key.FromId)
&& !changedDataFileIds.Contains(pair.Key.ToId)));
}
WorkspaceData = workspaceData;
}
public MoleculeAccessionNumbers(IDictionary <string, string> keys)
{
var nonEmptyKeys = keys == null ? new KeyValuePair <string, string>[] {} : keys.Where(kvp => !string.IsNullOrEmpty(kvp.Value)).ToArray();
AccessionNumbers = ImmutableSortedList <string, string> .FromValues(nonEmptyKeys, ACCESSION_TYPE_SORTER);
}
public WorkspaceData SetMsDataFiles(ImmutableSortedList<long, MsDataFileData> value)
{
return new WorkspaceData(this){MsDataFiles = value};
}
protected override WorkspaceData SetData(WorkspaceData workspaceData, ImmutableSortedList <long, PeptideAnalysisData> data)
{
return(workspaceData.SetPeptideAnalyses(data));
}
public WorkspaceData SetPeptides(ImmutableSortedList<long, PeptideData> value)
{
return new WorkspaceData(this){Peptides = value};
}
protected override WorkspaceData SetData(WorkspaceData workspaceData, ImmutableSortedList <long, MsDataFileData> data)
{
return(workspaceData.SetMsDataFiles(data));
}
public WorkspaceData SetSettings(ImmutableSortedList<string, string> value)
{
return new WorkspaceData(this){Settings = value};
}
public void CompareValues(WorkspaceChangeArgs workspaceChange, ImmutableSortedList <TKey, TValue> newValues)
{
Diff(workspaceChange, newValues, Data);
}
public WorkspaceData SetTracerDefs(ImmutableSortedList<string, TracerDefData> value)
{
return new WorkspaceData(this){TracerDefs = value};
}
public PeptideAnalysisData SetFileAnalyses(ImmutableSortedList<long, PeptideFileAnalysisData> fileAnalyses, bool chromatogramsWereLoaded)
{
return new PeptideAnalysisData(this)
{
ChromatogramsWereLoaded = chromatogramsWereLoaded,
FileAnalyses = fileAnalyses,
};
}
public RetentionTimeAlignments(WorkspaceData workspaceData)
{
WorkspaceData = workspaceData;
_alignments = ImmutableSortedList<AlignmentKey, RetentionTimeAlignment>.EMPTY;
}
