private void OnStatus(string message)
{
ThreadSafeDispatcher.Invoke(() =>
{
ApplicationStatusMediator.SetStatus(message);
Status = message;
});
}
public void CreateAlignmentPlots(FeaturesAlignedEventArgs e)
{
Action workAction = () =>
{
BuildAlignmentPlotView(e);
Reporter.CreateAlignmentPlots(e);
};
ThreadSafeDispatcher.Invoke(workAction);
}
public void CreateMassTagPlot(MassTagsLoadedEventArgs e)
{
Action workAction = () =>
{
BuildMassTagPlots(e);
Reporter.CreateMassTagPlot(e);
};
ThreadSafeDispatcher.Invoke(workAction);
}
public void CreateBaselinePlots(BaselineFeaturesLoadedEventArgs e)
{
Action workAction = () =>
{
BuildBaselineView(e);
Reporter.CreateBaselinePlots(e);
};
ThreadSafeDispatcher.Invoke(workAction);
}
public void CreateClusterPlots(FeaturesClusteredEventArgs clusters)
{
Action workAction = () =>
{
BuildClusterPlots(clusters.Clusters);
Reporter.CreateClusterPlots(clusters);
};
ThreadSafeDispatcher.Invoke(workAction);
}
private void ControllerOnAnalysisStarted(object sender, AnalysisGraphEventArgs analysisGraphEventArgs)
{
Action workAction = () =>
{
AnalysisNodes.Clear();
analysisGraphEventArgs.AnalysisGraph.Nodes.ForEach(
x => AnalysisNodes.Add(new AnalysisGraphNodeViewModel(x)));
};
ThreadSafeDispatcher.Invoke(workAction);
}
/// <summary>
/// Cosntructor
/// </summary>
/// <param name="analysis"></param>
/// <param name="datasets"></param>
/// <param name="msFeatureWindowFactory"></param>
public FeatureFindingSettingsViewModel(
MultiAlignAnalysis analysis,
ObservableCollection <DatasetInformationViewModel> datasets,
IFeatureWindowFactory msFeatureWindowFactory = null)
{
this.analysis = analysis;
this.Datasets = datasets;
this.msFeatureWindowFactory = msFeatureWindowFactory ?? new MSFeatureViewFactory();
this.msFeatureWindowFactory = new MSFeatureViewFactory();
this.featuresByDataset = new Dictionary <DatasetInformation, IList <UMCLight> >();
this.MsFeatureClusterers = new ObservableCollection <MsFeatureClusteringAlgorithmType>(
Enum.GetValues(typeof(MsFeatureClusteringAlgorithmType)).Cast <MsFeatureClusteringAlgorithmType>());
this.LcmsFeatureClusterers = new ObservableCollection <GenericClusteringAlgorithmType>(
Enum.GetValues(typeof(GenericClusteringAlgorithmType)).Cast <GenericClusteringAlgorithmType>());
this.CanCreateXics = datasets.Select(dataset => RawLoaderFactory.CreateFileReader(dataset.Dataset.RawFile.Path, dataset.DatasetId))
.Any(reader => reader is ISpectraProvider);
// When dataset is selected/unselected, update can executes.
this.MessengerInstance.Register <PropertyChangedMessage <bool> >(this, this.UpdateDatasetSelection);
// When dataset state changes, update can executes.
this.MessengerInstance.Register <PropertyChangedMessage <DatasetInformationViewModel.DatasetStates> >(this, args =>
{
if (args.Sender is DatasetInformationViewModel && args.PropertyName == "DatasetState")
{
ThreadSafeDispatcher.Invoke(() =>
{
this.FindMsFeaturesCommand.RaiseCanExecuteChanged();
this.PlotMsFeaturesCommand.RaiseCanExecuteChanged();
this.PlotAlignedFeaturesCommand.RaiseCanExecuteChanged();
});
}
});
this.FindMsFeaturesCommand = new RelayCommand(
async() => await this.LoadMsFeaturesAsync(),
() => this.Datasets.Any(ds => ds.IsSelected && !ds.IsFindingFeatures));
this.PlotMsFeaturesCommand = new RelayCommand(
async() => await this.PlotMsFeatures(false),
() => this.Datasets.Any(
ds =>
ds.DatasetState >
DatasetInformationViewModel.DatasetStates.FindingFeatures &&
ds.IsSelected));
this.PlotAlignedFeaturesCommand = new RelayCommand(
async() => await this.PlotMsFeatures(true),
() => this.Datasets.Any(ds => ds.IsAligned));
this.RestoreDefaultsCommand = new RelayCommand(this.RestoreDefaults);
}
public AnalysisGraphNodeViewModel(AnalysisGraphNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
// This safely updates the UI thread in case the current analysis is running on a separate thread.
Action update = () => OnPropertyChanged("IsCurrent");
m_node = node;
m_node.StatusChanged += (sender, args) => ThreadSafeDispatcher.Invoke(update);
}
/// <summary>
/// Loads the analysis.
/// </summary>
/// <param name="recentAnalysis"></param>
public void LoadAnalysis(RecentAnalysis recentAnalysis)
{
if (recentAnalysis == null)
{
OnStatus("Cannot open analysis file.");
return;
}
Action loadAnalysis = delegate
{
var filename = Path.Combine(recentAnalysis.Path, recentAnalysis.Name);
OnStatus("Gaining access to the analysis database...");
var providers = DataAccessFactory.CreateDataAccessProviders(filename, false);
var analysis = new MultiAlignAnalysis();
analysis.MetaData.AnalysisPath = recentAnalysis.Path;
analysis.MetaData.AnalysisName = recentAnalysis.Name;
analysis.MetaData.AnalysisSetupInfo = null;
analysis.DataProviders = providers;
OnStatus("Detecting your clusters...");
analysis.Clusters = providers.ClusterCache.FindAll();
OnStatus("Updating your datasets...");
analysis.MetaData.Datasets = providers.DatasetCache.FindAll().ToObservableCollection();
OnStatus("Securing mass tags...");
var provider = new MassTagDatabaseLoaderCache();
provider.Provider = analysis.DataProviders.MassTags;
analysis.MassTagDatabase = provider.LoadDatabase();
OnStatus("Analysis Loaded...");
ThreadSafeDispatcher.Invoke(() =>
{
if (AnalysisLoaded != null)
{
AnalysisLoaded(this, new AnalysisStatusArgs(analysis));
}
});
};
m_loadingTask = new Task(loadAnalysis);
m_loadingTask.Start();
}
public ClusterSettingsViewModel(
MultiAlignAnalysis analysis,
ObservableCollection <DatasetInformationViewModel> datasets,
IClusterViewFactory clusterViewFactory = null,
IProgress <int> progressReporter = null)
{
this.progress = progressReporter ?? new Progress <int>();
this.analysis = analysis;
this.Datasets = datasets;
this.options = analysis.Options;
this.builder = new AlgorithmBuilder();
this.clusterViewFactory = clusterViewFactory ?? new ClusterViewFactory(analysis.DataProviders);
// When dataset state changes, update can executes.
this.MessengerInstance.Register <PropertyChangedMessage <DatasetInformationViewModel.DatasetStates> >(this, args =>
{
if (args.Sender is DatasetInformationViewModel && args.PropertyName == "DatasetState")
{
ThreadSafeDispatcher.Invoke(() => this.ClusterFeaturesCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayClustersCommand.RaiseCanExecuteChanged());
}
});
this.ClusterFeaturesCommand = new RelayCommand(this.AsyncClusterFeatures, () => this.Datasets.Any(ds => ds.FeaturesFound));
this.DisplayClustersCommand = new RelayCommand(
async() => await this.DisplayFeatures(),
() => this.Datasets.Any(ds => ds.IsClustered));
this.DistanceMetrics = new ObservableCollection <DistanceMetric>();
Enum.GetValues(typeof(DistanceMetric)).Cast <DistanceMetric>().ToList().ForEach(x => this.DistanceMetrics.Add(x));
this.CentroidRepresentations = new ObservableCollection <ClusterCentroidRepresentation>
{
ClusterCentroidRepresentation.Mean,
ClusterCentroidRepresentation.Median
};
this.ClusteringMethods = new ObservableCollection <LcmsFeatureClusteringAlgorithmType>();
Enum.GetValues(typeof(LcmsFeatureClusteringAlgorithmType)).Cast <LcmsFeatureClusteringAlgorithmType>().ToList().ForEach(x => this.ClusteringMethods.Add(x));
this.PostProcessingComparisonType = new ObservableCollection <ClusterPostProcessingOptions.ClusterComparisonType>(
Enum.GetValues(typeof(ClusterPostProcessingOptions.ClusterComparisonType)).Cast <ClusterPostProcessingOptions.ClusterComparisonType>());
}
private void LoadFeatures()
{
this.featureCache.Providers = this.analysis.DataProviders;
var selectedFiles = selectedDatasets;
foreach (var file in selectedFiles.Where(file => !file.DoingWork)) // Do not try to run on files already loading features.
{
file.DoingWork = true;
ThreadSafeDispatcher.Invoke(() => PlotMSFeaturesCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => FindMSFeaturesCommand.RaiseCanExecuteChanged());
var features = this.featureCache.LoadDataset(file, this.analysis.Options.MsFilteringOptions, this.analysis.Options.LcmsFindingOptions, this.analysis.Options.LcmsFilteringOptions);
this.featureCache.CacheFeatures(features);
file.FeaturesFound = true;
progress.Report(0);
file.DoingWork = false;
ThreadSafeDispatcher.Invoke(() => PlotMSFeaturesCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => FindMSFeaturesCommand.RaiseCanExecuteChanged());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="StacSettingsViewModel"/> class.
/// </summary>
/// <param name="analysis">The analysis information to run matching on.</param>
/// <param name="datasets">All possible datasets to run AMT tag matching on.</param>
public StacSettingsViewModel(MultiAlignAnalysis analysis, ObservableCollection <DatasetInformationViewModel> datasets)
{
this.analysis = analysis;
this.datasets = datasets;
this.DatabaseSelectionViewModel = DatabaseSelectionViewModel.Instance;
this.PeakMatchingTypes = new ObservableCollection <PeakMatchingType>(
Enum.GetValues(typeof(PeakMatchingType))
.Cast <PeakMatchingType>());
// When a dataset's state changes, update the CanExecute of the PerformMatchingCommand.
MessengerInstance.Register <PropertyChangedMessage <DatasetInformationViewModel.DatasetStates> >(
this,
args =>
{
if (args.Sender is DatasetInformationViewModel && args.PropertyName == "DatasetState")
{
ThreadSafeDispatcher.Invoke(this.PerformMatchingCommand.RaiseCanExecuteChanged);
}
});
// When a dataset is selected/unselected, update the CanExecute of the PerformMatchingCommand.
MessengerInstance.Register <PropertyChangedMessage <bool> >(
this,
args =>
{
if (args.Sender is DatasetInformationViewModel && args.PropertyName == "IsSelected")
{
ThreadSafeDispatcher.Invoke(this.PerformMatchingCommand.RaiseCanExecuteChanged);
}
});
// Perform matching on datasets that have cluster info available, and are not
// currently being run.
this.PerformMatchingCommand = new RelayCommand(
async() => await this.PerformMatchingAsync(
this.datasets.Where(ds => ds.IsClustered)
.Where(ds => !ds.DoingWork)),
() => this.datasets.Any(ds => ds.IsClustered && !ds.DoingWork));
}
private void AnalysisEnded(string reason, bool isCancelled, bool isComplete)
{
Action workAction = delegate
{
IsAnalysisRunning = false;
ApplicationStatusMediator.SetStatus(reason);
Controller.AnalysisComplete -= Controller_AnalysisComplete;
Controller.AnalysisError -= Controller_AnalysisError;
Controller.AnalysisCancelled -= Controller_AnalysisCancelled;
if (isComplete)
{
if (AnalysisComplete != null)
{
AnalysisComplete(this, new AnalysisStatusArgs(m_configuration));
}
return;
}
if (!isCancelled)
{
if (AnalysisComplete != null)
{
AnalysisComplete(this, new AnalysisStatusArgs(m_configuration));
}
}
else
{
if (AnalysisCancelled != null)
{
AnalysisCancelled(this, new AnalysisStatusArgs(m_configuration));
}
}
};
ThreadSafeDispatcher.Invoke(workAction);
}
/// <summary>
/// Copy files from DMS dataset folder to output directory.
/// </summary>
/// <returns>Task for awaiting file copy.</returns>
public async Task CopyFilesAsync()
{
this.cancellationTokenSource = new CancellationTokenSource();
await Task.Run(
() =>
{
if (!Directory.Exists(this.OutputDirectory))
{
return;
}
ThreadSafeDispatcher.Invoke(() => this.IsCopying = true);
this.Progress = 0;
var files = this.Datasets.Where(ds => ds.Selected).SelectMany(ds => ds.GetAvailableFiles()).ToArray();
for (int i = 0; i < files.Length; i++)
{
if (this.cancellationTokenSource.IsCancellationRequested)
{
break;
}
var fileName = Path.GetFileName(files[i]);
this.CopyStatusText = string.Format("Copying {0}", fileName);
File.Copy(files[i], string.Format("{0}\\{1}", this.OutputDirectory, fileName), true);
this.Progress = ((i + 1) / (double)files.Length) * 100;
}
this.CopyStatusText = string.Empty;
ThreadSafeDispatcher.Invoke(() => this.IsCopying = false);
this.Progress = 100;
},
this.cancellationTokenSource.Token);
}
public void CreatePlotReport()
{
Action workAction = () => Reporter.CreatePlotReport();
ThreadSafeDispatcher.Invoke(workAction);
}
/// <summary>
/// Updates the current messages windows.
/// </summary>
private void Logger_Status(object sender, StatusEventArgs e)
{
Action workAction = () => Messages.Insert(0, e);
ThreadSafeDispatcher.Invoke(workAction);
}
/// <summary>
/// Initializes a new instance of the <see cref="AlignmentSettingsViewModel"/> class.
/// </summary>
/// <param name="analysis">The analysis information to run alignment on.</param>
/// <param name="datasets">List of all potential datasets to run alignment on.</param>
/// <param name="alignmentWindowFactory">
/// Factory for creating windows related to alignment (such as alignment plot windows).
/// </param>
public AlignmentSettingsViewModel(MultiAlignAnalysis analysis,
ObservableCollection <DatasetInformationViewModel> datasets,
IAlignmentWindowFactory alignmentWindowFactory = null)
{
this.analysis = analysis;
this.Datasets = datasets;
if (analysis.MetaData.BaselineDataset != null)
{
// Don't set baseline if there are no files to choose from yet
this.selectedBaseline = datasets.First(x => x.Name == analysis.MetaData.BaselineDataset.DatasetName);
}
this.alignmentWindowFactory = alignmentWindowFactory ?? new AlignmentViewFactory();
this.aligner = new LCMSFeatureAligner();
this.builder = new AlgorithmBuilder();
this.CalibrationOptions = new ObservableCollection <LcmsWarpAlignmentType>(Enum.GetValues(typeof(LcmsWarpAlignmentType)).Cast <LcmsWarpAlignmentType>());
this.AlignmentAlgorithms = new ObservableCollection <FeatureAlignmentType>(
Enum.GetValues(typeof(FeatureAlignmentType)).Cast <FeatureAlignmentType>());
this.alignmentInformation = new List <AlignmentData>();
this.DatabaseSelectionViewModel = DatabaseSelectionViewModel.Instance;
// When dataset is selected/unselected, update CanExecutes for alignment and plotting commands.
this.MessengerInstance.Register <PropertyChangedMessage <bool> >(
this,
args =>
{
if (args.Sender is DatasetInformationViewModel && args.PropertyName == "IsSelected")
{
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged());
}
});
// When dataset state changes, update CanExecutes for alignment and plotting commands.
this.MessengerInstance.Register <PropertyChangedMessage <DatasetInformationViewModel.DatasetStates> >(
this,
args =>
{
if (args.Sender is DatasetInformationViewModel && args.PropertyName == "DatasetState")
{
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged());
}
});
// When database server is selected, update CanExecute for the alignment command.
this.MessengerInstance.Register <PropertyChangedMessage <DmsDatabaseServerViewModel> >(
this,
args =>
{
if (args.Sender is DatabaseSelectionViewModel && args.PropertyName == "SelectedDatabase")
{
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
}
});
this.AlignCommand = new RelayCommand(this.AsyncAlign, this.CanAlign);
// Executable if the selected files are aligned and alignment information is available.
this.DisplayAlignmentCommand = new RelayCommand(
this.DisplayAlignment,
() => this.Datasets.Any(file => file.IsAligned && file.IsSelected &&
this.alignmentInformation.Any(data => data.DatasetID == file.DatasetId)));
// Executable if the selected files are aligned and alignment information is available.
this.SaveAlignmentPlotsCommand = new RelayCommand(
this.SaveAlignmentPlots,
() => this.Datasets.Any(file => file.IsAligned && file.IsSelected &&
this.alignmentInformation.Any(data => data.DatasetID == file.DatasetId)));
this.RestoreDefaultsCommand = new RelayCommand(this.RestoreDefaults);
}
public void CreateChargePlots(Dictionary <int, int> chargeMap)
{
Action workAction = () => Reporter.CreateChargePlots(chargeMap);
ThreadSafeDispatcher.Invoke(workAction);
}
public void CreatePeakMatchedPlots(FeaturesPeakMatchedEventArgs e)
{
Action workAction = () => Reporter.CreatePeakMatchedPlots(e);
ThreadSafeDispatcher.Invoke(workAction);
}
/// <summary>
/// Perform alignment.
/// </summary>
/// <param name="workFlowDatasets">Datasets to run on when being called externally form this view model.</param>
/// <param name="workflowProgress">The progress reporter for when this method is called externally from this view model.</param>
internal void AlignToBaseline(List <DatasetInformationViewModel> workFlowDatasets = null, IProgress <ProgressData> workflowProgress = null)
{
// Use Promiscuous points when aligning to an AMT tag database
// Do not use Promiscuous points when aligning to a baseline dataset
this.analysis.Options.AlignmentOptions.UsePromiscuousPoints = !this.ShouldAlignToBaseline;
// Flag whether we are aligning to an AMT tag database
this.analysis.Options.AlignmentOptions.LCMSWarpOptions.AlignToMassTagDatabase = !this.ShouldAlignToBaseline;
// Show the progress bar
this.ShowAlignmentProgress = true;
var taskBarProgress = TaskBarProgress.GetInstance();
taskBarProgress.ShowProgress(this, true);
// Update algorithms and providers
var featureCache = new FeatureLoader {
Providers = this.analysis.DataProviders
};
this.algorithms = this.builder.GetAlgorithmProvider(this.analysis.Options);
////this.algorithms.DatabaseAligner.Progress += aligner_Progress;
////this.algorithms.DatasetAligner.Progress += aligner_Progress;
this.aligner.m_algorithms = this.algorithms;
var baselineFeatures = new List <UMCLight>();
if (this.ShouldAlignToBaseline)
{
baselineFeatures = featureCache.Providers.FeatureCache.FindByDatasetId(this.selectedBaseline.DatasetId);
this.SelectedBaseline.DatasetState = DatasetInformationViewModel.DatasetStates.Baseline;
var priorAlignment = (from x in this.alignmentInformation where x.DatasetID == this.selectedBaseline.DatasetId select x).ToList();
if (priorAlignment.Any())
{
this.alignmentInformation.Remove(priorAlignment.Single());
}
}
var alignmentData = new AlignmentDAOHibernate();
alignmentData.ClearAll();
var selectedFiles = workFlowDatasets ??
this.Datasets.Where(file => file.IsSelected && !file.DoingWork &&
(this.ShouldAlignToAMT || !file.IsBaseline)).ToList();
foreach (var file in selectedFiles)
{
file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligning;
}
workflowProgress = workflowProgress ?? new Progress <ProgressData>();
IProgress <ProgressData> totalProgress = new Progress <ProgressData>(pd =>
{
this.AlignmentProgress = pd.Percent;
workflowProgress.Report(pd);
taskBarProgress.SetProgress(this, pd.Percent);
});
var totalProgressData = new ProgressData(totalProgress);
DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path);
DatabaseIndexer.IndexFeaturesDrop(NHibernateUtil.Path);
var i = 1;
foreach (var file in selectedFiles)
{
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged());
if ((file.Dataset.IsBaseline || !file.FeaturesFound) && this.ShouldAlignToBaseline)
{
file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned;
continue;
}
this.analysis.DataProviders.DatabaseLock.EnterReadLock();
IList <UMCLight> features = featureCache.Providers.FeatureCache.FindByDatasetId(file.DatasetId);
this.analysis.DataProviders.DatabaseLock.ExitReadLock();
AlignmentData alignment;
totalProgressData.StepRange((100.0 * i++) / selectedFiles.Count);
var fileInstance = file;
var datasetProgress =
new Progress <ProgressData>(
pd =>
{
fileInstance.Progress = pd.Percent;
totalProgressData.Report(pd.Percent);
});
if (this.ShouldAlignToBaseline)
{
// Aligning to a baseline dataset
alignment = this.aligner.AlignToDataset(ref features, file.Dataset, baselineFeatures, datasetProgress);
alignment.BaselineIsAmtDB = false;
}
else
{
// Aligning to a database
alignment = this.aligner.AlignToDatabase(ref features, file.Dataset, this.analysis.MassTagDatabase, datasetProgress);
alignment.BaselineIsAmtDB = true;
}
// Check if there is information from a previous alignment for this dataset. If so, replace it. If not, just add the new one.
var priorAlignment = this.alignmentInformation.Where(x => x.DatasetID == alignment.DatasetID).ToList();
if (priorAlignment.Any())
{
this.alignmentInformation.Remove(priorAlignment.Single());
this.alignmentInformation.Add(alignment);
}
else
{
this.alignmentInformation.Add(alignment);
}
file.Dataset.AlignmentData = alignment;
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
featureCache.CacheFeatures(features);
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned;
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged());
file.Progress = 0;
}
if (this.ShouldAlignToBaseline)
{
this.SelectedBaseline.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned;
}
DatabaseIndexer.IndexFeatures(NHibernateUtil.Path);
taskBarProgress.ShowProgress(this, false);
this.ShowAlignmentProgress = false;
this.AlignmentProgress = 0;
}
internal void ClusterFeatures(IProgress <ProgressData> workflowProgress = null)
{
var taskBarProgress = TaskBarProgress.GetInstance();
taskBarProgress.ShowProgress(this, true);
workflowProgress = workflowProgress ?? new Progress <ProgressData>();
IProgress <ProgressData> internalProgress = new Progress <ProgressData>(pd =>
{
this.progress.Report((int)pd.Percent);
this.ProgressPercent = pd.Percent;
taskBarProgress.SetProgress(this, pd.Percent);
workflowProgress.Report(pd);
});
this.algorithms = this.builder.GetAlgorithmProvider(this.options);
var clusterer = this.algorithms.Clusterer;
clusterer.Parameters = LcmsClusteringOptions.ConvertToOmics(this.options.LcmsClusteringOptions);
this.featureCache = this.analysis.DataProviders.FeatureCache;
if (clusterer is PromexClusterer)
{
var promexClusterer = clusterer as PromexClusterer;
promexClusterer.Readers = this.analysis.DataProviders.ScanSummaryProviderCache;
}
foreach (var dataset in this.Datasets)
{
if (dataset.FeaturesFound)
{
dataset.DatasetState = DatasetInformationViewModel.DatasetStates.Clustering;
}
}
ThreadSafeDispatcher.Invoke(this.ClusterFeaturesCommand.RaiseCanExecuteChanged);
ThreadSafeDispatcher.Invoke(this.DisplayClustersCommand.RaiseCanExecuteChanged);
this.ShouldShowProgress = true;
var progData = new ProgressData(internalProgress);
var clusterProgress = new Progress <ProgressData>(pd => progData.Report(pd.Percent));
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path);
this.analysis.DataProviders.ClusterCache.ClearAllClusters();
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
// The id for a cluster - keep track here to avoid duplicates when separating by charge.
var clusterCount = 0;
// Here we see if we need to separate the charge...
// IMS is said to require charge separation
if (!this.analysis.Options.LcmsClusteringOptions.ShouldSeparateCharge)
{
progData.StepRange(45);
var features = new List <UMCLight>();
var i = 0;
var datasets = this.Datasets.Where(ds => ds.FeaturesFound).ToList();
foreach (var dataset in datasets)
{
this.analysis.DataProviders.DatabaseLock.EnterReadLock();
features.AddRange(this.featureCache.FindByDatasetId(dataset.DatasetId));
this.analysis.DataProviders.DatabaseLock.ExitReadLock();
progData.Report(++i, datasets.Count);
}
progData.StepRange(100);
ClusterGroupOfFeatures(clusterer, features, ref clusterCount, clusterProgress);
}
else
{
var maxChargeState = this.featureCache.FindMaxCharge();
// Here we cluster all charge states separately. Probably IMS Data.
for (var chargeState = 1; chargeState <= maxChargeState; chargeState++)
{
var maxPercent = ((100.0 * chargeState) / maxChargeState);
// TODO: Add restriction by selected dataset ids?
var features = this.featureCache.FindByCharge(chargeState);
if (features.Count < 1)
{
continue;
}
progData.StepRange(maxPercent);
ClusterGroupOfFeatures(clusterer, features, ref clusterCount, clusterProgress);
}
this.analysis.Clusters = this.analysis.DataProviders.ClusterCache.FindAll();
}
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
DatabaseIndexer.IndexClusters(NHibernateUtil.Path);
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
foreach (var dataset in this.Datasets)
{
if (dataset.DatasetState == DatasetInformationViewModel.DatasetStates.PersistingClusters)
{
dataset.DatasetState = DatasetInformationViewModel.DatasetStates.Clustered;
}
}
try
{
// Write to file
this.WriteClusterData(string.Format("{0}_crosstab.tsv", this.analysis.AnalysisName), this.analysis.Clusters);
}
catch (Exception ex)
{
var errMsg = "Error writing results to text file: " + ex.Message;
Logger.PrintMessage(errMsg);
// Todo: Add this: if (!GlobalSettings.AutomatedAnalysisMode)
MessageBox.Show(errMsg);
}
ThreadSafeDispatcher.Invoke(this.ClusterFeaturesCommand.RaiseCanExecuteChanged);
ThreadSafeDispatcher.Invoke(this.DisplayClustersCommand.RaiseCanExecuteChanged);
taskBarProgress.ShowProgress(this, false);
this.ShouldShowProgress = false;
}
internal void ClusterGroupOfFeatures(IClusterer <UMCLight, UMCClusterLight> clusterer, List <UMCLight> features, ref int clusterCount, IProgress <ProgressData> internalProgress = null)
{
var progData = new ProgressData(internalProgress);
var clusterProgress = new Progress <ProgressData>(pd => progData.Report(pd.Percent));
if (this.ShouldRefineWithMsMs)
{
progData.StepRange(35);
}
else
{
progData.StepRange(70);
}
var clusters = clusterer.Cluster(features, clusterProgress);
foreach (var cluster in clusters)
{
cluster.Id = clusterCount++;
cluster.UmcList.ForEach(x => x.ClusterId = cluster.Id);
// Updates the cluster with statistics
foreach (var feature in cluster.UmcList)
{
cluster.MsMsCount += feature.MsMsCount;
cluster.IdentifiedSpectraCount += feature.IdentifiedSpectraCount;
}
}
if (this.ShouldRefineWithMsMs)
{
try
{
progData.StepRange(70);
var clusterRefiner =
ClusterPostProcessorBuilder.GetClusterPostProcessor <UMCClusterLight, UMCLight>(
this.analysis.Options.ClusterPostProcessingoptions,
this.analysis.DataProviders);
clusters = clusterRefiner.Cluster(clusters, clusterProgress);
}
catch (DatasetInformation.MissingRawDataException e)
{
MessageBox.Show(string.Format("{0}\nDataset: {1}", e.Message, e.GroupId));
}
}
this.analysis.Clusters = clusters;
clusters.ForEach(c => c.Abundance = c.UmcList.Sum(umc => umc.AbundanceSum));
foreach (var dataset in this.Datasets)
{
if (dataset.DatasetState == DatasetInformationViewModel.DatasetStates.Clustering)
{
dataset.DatasetState = DatasetInformationViewModel.DatasetStates.PersistingClusters;
}
}
ThreadSafeDispatcher.Invoke(this.ClusterFeaturesCommand.RaiseCanExecuteChanged);
ThreadSafeDispatcher.Invoke(this.DisplayClustersCommand.RaiseCanExecuteChanged);
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
progData.StepRange(85);
this.analysis.DataProviders.ClusterCache.AddAllStateless(clusters, clusterProgress);
progData.StepRange(100);
this.analysis.DataProviders.FeatureCache.UpdateAll(features, clusterProgress);
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
}
internal void LoadFeatures(List <DatasetInformationViewModel> workFlowDatasets = null, IProgress <ProgressData> workflowProgress = null)
{
var featureCache = new FeatureLoader {
Providers = this.analysis.DataProviders
};
this.ShouldShowProgress = true;
var selectedFiles = workFlowDatasets ?? this.Datasets.Where(file => !file.DoingWork).Where(ds => ds.IsSelected).ToList();
foreach (var file in selectedFiles)
{
file.DatasetState = DatasetInformationViewModel.DatasetStates.FindingFeatures;
ThreadSafeDispatcher.Invoke(() => this.PlotMsFeaturesCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.FindMsFeaturesCommand.RaiseCanExecuteChanged());
}
var taskBarProgress = TaskBarProgress.GetInstance();
taskBarProgress.ShowProgress(this, true);
workflowProgress = workflowProgress ?? new Progress <ProgressData>();
IProgress <ProgressData> totalProgressRpt = new Progress <ProgressData>(pd =>
{
this.TotalProgress = pd.Percent;
taskBarProgress.SetProgress(this, pd.Percent);
workflowProgress.Report(pd);
});
var totalProgressData = new ProgressData(totalProgressRpt);
DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path);
DatabaseIndexer.IndexFeaturesDrop(NHibernateUtil.Path);
var i = 1;
foreach (var file in selectedFiles)
{
// Set range based on file
totalProgressData.StepRange((i++ *100.0) / selectedFiles.Count);
var fileInstance = file;
var progData = new ProgressData(new Progress <ProgressData>(pd =>
{
fileInstance.Progress = pd.Percent;
// Report file progress
totalProgressData.Report(fileInstance.Progress);
}));
var progressRpt = new Progress <ProgressData>(pd => progData.Report(pd.Percent));
progData.StepRange(30);
IList <UMCLight> features;
// Load features from the database.
try
{
this.analysis.DataProviders.DatabaseLock.EnterReadLock();
features = featureCache.LoadDataset(
file.Dataset,
this.analysis.Options.MsFilteringOptions,
this.analysis.Options.LcmsFindingOptions,
this.analysis.Options.LcmsFilteringOptions,
this.analysis.Options.DataLoadOptions,
this.analysis.DataProviders.ScanSummaryProviderCache,
this.analysis.DataProviders.IdentificationProviderCache,
progressRpt);
}
finally
{ // Always close read lock, even during failure condition so we don't have a recursive lock error.
this.analysis.DataProviders.DatabaseLock.ExitReadLock();
}
if (!this.featuresByDataset.ContainsKey(file.Dataset))
{
this.featuresByDataset.Add(file.Dataset, new List <UMCLight>());
}
this.featuresByDataset[file.Dataset] = features;
file.DatasetState = DatasetInformationViewModel.DatasetStates.PersistingFeatures;
ThreadSafeDispatcher.Invoke(() => this.PlotMsFeaturesCommand.RaiseCanExecuteChanged());
// TODO: We were using this log file to track speed changes for writing the database. We probably don't need it anymore.
using (var logger = new StreamWriter("nhibernate_stats.txt", true))
{
logger.WriteLine();
var stopWatch = new Stopwatch();
stopWatch.Start();
var scanSumProvider =
this.analysis.DataProviders.ScanSummaryProviderCache.GetScanSummaryProvider(
file.Dataset.DatasetId);
if (scanSumProvider.IsBackedByFile)
{
var ssDao = this.analysis.DataProviders.ScanSummaryDao;
ssDao.DeleteByDatasetId(file.Dataset.DatasetId);
// Add all of the Scan Summaries for this dataset to the database, but first properly set the dataset ID
ssDao.AddAllStateless(
scanSumProvider.GetScanSummaries().Select(
summ =>
{
summ.DatasetId = file.Dataset.DatasetId;
return(summ);
}).ToList());
}
progData.StepRange(100);
// Cache features to database.
try
{
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
featureCache.CacheFeatures(features, progressRpt);
}
catch (NonUniqueObjectException ex)
{
MessageBox.Show("Could not completely persist features: " + ex.Message);
}
catch (Exception ex) // TODO: Figure out which exception should actually be caught here
{
MessageBox.Show("Could not persist features to database: " + ex.Message);
file.DatasetState = DatasetInformationViewModel.DatasetStates.Loaded;
continue;
}
finally
{ // Always close write lock, even during failure condition so we don't have a recursive lock error.
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
}
stopWatch.Stop();
logger.WriteLine("Writing: {0}s", stopWatch.Elapsed.TotalSeconds);
}
file.DatasetState = DatasetInformationViewModel.DatasetStates.FeaturesFound;
ThreadSafeDispatcher.Invoke(() => this.FindMsFeaturesCommand.RaiseCanExecuteChanged());
file.Progress = 0;
}
DatabaseIndexer.IndexFeatures(NHibernateUtil.Path);
taskBarProgress.ShowProgress(this, false);
this.ShouldShowProgress = false;
}
