/// <summary>
/// Displays the selected dataset.
/// </summary>
private void ShowSelectedDataset()
{
try
{
Analysis analysis = GetSelectedAnalysis();
if (analysis != null)
{
m_selectedAnalysis = analysis;
// If the analysis has not been processed, then do so...
if (analysis.ProcessedState != ProcessingState.Processed)
{
//LockUserInterface(true);
IRetentionTimePredictor predictor = RetentionTimePredictorFactory.CreatePredictor(m_options.PredictorType);
m_processor.ProcessAnalysisJob(analysis,
m_options,
predictor);
}
else
{
ctlChartScanVsNET.SeriesCollection.Clear();
DisplayScansVsNet(analysis);
}
}
else
{
OnStatus("No analysis was selected.");
}
}
catch (Exception ex)
{
OnStatus(ex.Message);
}
}
/// <summary>
/// Calculate the Normal Elution Time
/// </summary>
/// <param name="results"></param>
protected void ComputeNets(IEnumerable <Evidence> results)
{
if (!AbortRequested)
{
UpdateProgress(99, "Loading elution times");
NETPredictor.CalculateObservedNet(results);
UpdateProgress(99, "Initializing NET predictor");
var netPredictor = RetentionTimePredictorFactory.CreatePredictor(ReaderOptions.PredictorType);
UpdateProgress(99, "Computing NET values");
NETPredictor.CalculatePredictedNet(netPredictor, results);
}
}
/// <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>
/// Processes a list of dataset objects and returns a MTDB.
/// </summary>
private MassTagDatabase CreateDatabaseInternal(
Options options,
List <Analysis> analysisDescriptions)
{
MassTagDatabase massTagDatabase = new MassTagDatabase();
IRetentionTimePredictor predictor = RetentionTimePredictorFactory.CreatePredictor(options.PredictorType);
bool success = true;
// Analyze each of the datasets, putting the results into the mass tag database
// To expedite this process, only analyze if the analysis has not already been processed.
int analysisNumber = 1;
foreach (Analysis analysis in analysisDescriptions)
{
try
{
if (analysis.ProcessedState != ProcessingState.Processed)
{
ProcessAnalysisJobInternal(analysis, options, predictor);
}
massTagDatabase.AddResults(analysis.Targets,
options.Regression,
predictor);
massTagDatabase.AddMetaData(analysis);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
if (AnalysisCompleted != null)
{
AnalysisCompleted(this, new AnalysisCompletedEventArgs(analysisNumber++, analysisDescriptions.Count, analysis));
}
}
catch (IOException ex)
{
analysis.ProcessedState = ProcessingState.NotProcessed;
success = false;
OnError(string.Format("Failed to open the analysis file {0} - {1}", analysis.FilePath, ex.Message));
break;
}
catch (AnalysisToolException ex)
{
analysis.ProcessedState = ProcessingState.NotProcessed;
success = false;
OnError(string.Format("The analysis failed for {0} - {1}", analysis.Name, ex.Message));
break;
}
catch (Exception ex)
{
analysis.ProcessedState = ProcessingState.NotProcessed;
success = false;
OnError(string.Format("The analysis failed for {0} - {1}", analysis.Name, ex.Message));
break;
}
}
if (success)
{
massTagDatabase.FinalizeDatabase();
}
else
{
massTagDatabase = null;
if (this.AnalysisFailed != null)
{
AnalysisFailed(this, new DatabaseCreatedEventArgs(null));
}
}
return(massTagDatabase);
}
