/// <summary>
/// Calculate the predicted NET of a single peptide
/// </summary>
/// <param name="peptide"></param>
/// <param name="predictor">Retention Time Predictor</param>
/// <returns></returns>
public double ComputePeptideNET(string peptide, IRetentionTimePredictor predictor)
{
double predictedNET;
if (!PeptideCache.TryGetValue(peptide, out predictedNET))
{
predictedNET = predictor.GetElutionTime(peptide);
PeptideCache.Add(peptide, predictedNET);
}
return(predictedNET);
}
/// <summary>
/// Perform target alignment
/// </summary>
/// <param name="evidences">Evidences to align</param>
/// <param name="baseline">Baseline evidences</param>
/// <returns></returns>
public LinearRegressionResult AlignTargets(List <Evidence> evidences, List <Evidence> baseline)
{
var observed = new List <double>();
var predicted = new List <double>();
foreach (var evidence in baseline)
{
Predictor = RetentionTimePredictorFactory.CreatePredictor(Options.PredictorType);
evidence.PredictedNet = Predictor.GetElutionTime(Evidence.CleanSequence(evidence.Sequence));
observed.Add(evidence.ObservedNet);
predicted.Add(evidence.PredictedNet);
}
Regressor = LinearRegressorFactory.Create(Options.RegressionType);
var result = Regressor.CalculateRegression(observed, predicted);
foreach (var evidence in evidences)
{
evidence.ObservedNet = Regressor.Transform(result, evidence.ObservedNet);
}
return(result);
}
/// <summary>
/// Adds a list of mass tags to the database.
/// </summary>
/// <param name="targets"></param>
/// <param name="predictor"></param>
private void AddMassTags(List <Target> targets,
IRetentionTimePredictor predictor)
{
foreach (Target target in targets)
{
string peptideWithMod = target.Sequence + target.SequenceData.ModificationDescription;
double highNorm = target.HighNormalizedScore;
// Here we see if the mass tag has already been added to the database
// If it has then update the tag's data if appropriate for the max values.
if (m_massTagMap.ContainsKey(peptideWithMod))
{
ConsensusTarget consensusTarget = m_massTagMap[peptideWithMod];
if (consensusTarget.HighNormalizedScore < highNorm)
{
consensusTarget.HighNormalizedScore = highNorm;
}
if (consensusTarget.LogEValue > target.LogPeptideEValue)
{
consensusTarget.LogEValue = target.LogPeptideEValue;
}
// Map the proteins
target.Proteins.ForEach(x => consensusTarget.AddProtein(x));
target.ParentTarget = consensusTarget;
consensusTarget.Targets.Add(target);
// Increment the number of observations
consensusTarget.NumberOfObservations++;
}
else
{
// Otherwise we create a new mass tag entry into the database.
ConsensusTarget consensusTarget = new ConsensusTarget();
consensusTarget.MonoisotopicMass = target.MonoisotopicMass - (target.Charge * ConsensusTarget.PROTON_MASS);
consensusTarget.Id = m_massTags.Count;
consensusTarget.LogEValue = target.LogPeptideEValue;
consensusTarget.HighNormalizedScore = highNorm;
consensusTarget.NumberOfObservations = 1;
consensusTarget.ModificationCount = target.SequenceData.ModificationCount;
consensusTarget.ModificationDescription = target.SequenceData.ModificationDescription;
consensusTarget.MultipleProteins = target.MultiProteinCount;
consensusTarget.PmtQualityScore = 0;
consensusTarget.Sequence = target.Sequence;
try
{
consensusTarget.CleanSequence = Target.CleanPeptide(consensusTarget.Sequence);
}
catch (Exception ex)
{
int x = 9;
x++;
if (x < 8)
{
}
}
consensusTarget.NetPredicted = predictor.GetElutionTime(target.CleanSequence);
consensusTarget.PeptideObservationCountPassingFilter = 0;
consensusTarget.Targets.Add(target);
// Then link the child target to these parents
target.ParentTarget = consensusTarget;
m_massTags.Add(consensusTarget);
m_massTagMap.Add(peptideWithMod, consensusTarget);
}
}
foreach (var consensusTarget in m_massTags)
{
Dictionary <string, Protein> proteins = new Dictionary <string, Protein>();
foreach (var target in consensusTarget.Targets)
{
foreach (var protein in target.Proteins)
{
if (!proteins.ContainsKey(protein.Reference))
{
consensusTarget.AddProtein(protein);
}
}
}
}
}
private void ProcessAnalysisJobInternal(Analysis analysis, Options options, IRetentionTimePredictor predictor)
{
analysis.ProcessedState = ProcessingState.Processing;
if (this.ProcessingAnalysis != null)
{
ProcessingAnalysis(this, new AnalysisCompletedEventArgs(1, 1, analysis));
}
IAnalysisReader reader = SequenceAnalysisToolsFactory.CreateReader(analysis.Tool);
ITargetFilter filter = TargetFilterFactory.CreateFilters(analysis.Tool, options);
IRegressionAlgorithm regressor = RegressorFactory.CreateRegressor(RegressorType.LcmsRegressor, options.Regression);
Analysis results = reader.Read(analysis.FilePath, analysis.Name);
List <Target> targets = new List <Target>();
Dictionary <string, Protein> proteins = new Dictionary <string, Protein>();
foreach (var target in results.Targets)
{
if (options.ShouldFilter(target))
{
continue;
}
targets.Add(target);
foreach (var protein in target.Proteins)
{
if (!proteins.ContainsKey(protein.Reference))
{
analysis.Proteins.Add(protein);
proteins.Add(protein.Reference, protein);
}
}
}
analysis.AddTargets(targets);
// Calculate the regression based on the target data
List <float> predicted = new List <float>();
List <float> scans = new List <float>();
int maxScan = 0;
int minScan = 0;
foreach (Target target in analysis.Targets)
{
// Filter the target here...based on use for alignment.
if (filter.ShouldFilter(target))
{
continue;
}
maxScan = Math.Max(maxScan, target.Scan);
minScan = Math.Min(minScan, target.Scan);
target.IsPredicted = true;
target.NetPredicted = predictor.GetElutionTime(target.CleanSequence);
scans.Add(target.Scan);
predicted.Add(Convert.ToSingle(target.NetPredicted));
}
analysis.RegressionResults = regressor.CalculateRegression(scans, predicted);
//analysis.RegressionResults.Regressor = regressor;
analysis.RegressionResults.MinScan = minScan;
analysis.RegressionResults.MaxScan = maxScan;
// Make the regression line data.
int scan = 0;
int delta = 5;
while (scan <= maxScan)
{
double y = regressor.GetTransformedNET(scan);
scan += delta;
analysis.RegressionResults.XValues.Add(Convert.ToDouble(scan));
analysis.RegressionResults.YValues.Add(y);
}
// Then make sure we align all against the predicted self
regressor.ApplyTransformation(analysis.Targets);
analysis.ProcessedState = ProcessingState.Processed;
}
