/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static IAnalysisReader CreateReader(SupportedTools tool)
{
IAnalysisReader reader = null;
switch (tool)
{
case SupportedTools.Sequest:
reader = new SequestAnalysisReader();
break;
case SupportedTools.XTandem:
reader = new XTandemAnalysisReader();
break;
case SupportedTools.MsgfPlus:
reader = new MsgfPlusAnalysisReader();
break;
case SupportedTools.NotSupported:
break;
default:
break;
}
return(reader);
}
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;
}
