/// <summary>
/// Returns the list of algorithms post build.
/// </summary>
/// <returns></returns>
public AlgorithmProvider GetAlgorithmProvider(MultiAlignAnalysisOptions options)
{
BuildClusterer(options.LcmsClusteringOptions.LcmsFeatureClusteringAlgorithm);
BuildAligner(options.AlignmentOptions.LCMSWarpOptions, options.SpectralOptions);
BuildPeakMatcher(options);
return(m_provider);
}
/// <summary>
/// Reads all non-ignored properties from options and contained classes into a list of <see cref="OptionPair"/>
/// </summary>
/// <param name="options">Options to parse into a List of <see cref="OptionPair"/></param>
/// <returns></returns>
/// <remarks>Ignore a property using a <see cref="IgnoreOptionProperty"/> attribute</remarks>
public static IList <OptionPair> PropertiesToList(MultiAlignAnalysisOptions options)
{
var list = new List <OptionPair>();
GetProperties(list, options);
return(list);
}
/// <summary>
/// Builds a peak matcher object.
/// </summary>
public void BuildPeakMatcher(MultiAlignAnalysisOptions options)
{
var tolerances = new FeatureMatcherTolerances();
var stanleyMatcher = new STACAdapter <UMCClusterLight>
{
Options =
{
HistogramBinWidth = options.StacOptions.HistogramBinWidth,
HistogramMultiplier = options.StacOptions.HistogramMultiplier,
ShiftAmount = options.StacOptions.ShiftAmount,
ShouldCalculateHistogramFDR = options.StacOptions.ShouldCalculateHistogramFDR,
ShouldCalculateShiftFDR = options.StacOptions.ShouldCalculateShiftFDR,
ShouldCalculateSLiC = options.StacOptions.ShouldCalculateSLiC,
ShouldCalculateSTAC = options.StacOptions.ShouldCalculateSTAC,
UseDriftTime = options.StacOptions.UseDriftTime,
UseEllipsoid = options.StacOptions.UseEllipsoid,
UsePriors = options.StacOptions.UsePriors
}
};
tolerances.DriftTimeTolerance = Convert.ToSingle(options.StacOptions.DriftTimeTolerance);
tolerances.MassTolerancePPM = options.StacOptions.MassTolerancePPM;
tolerances.NETTolerance = options.StacOptions.NETTolerance;
tolerances.Refined = options.StacOptions.Refined;
stanleyMatcher.Options.UserTolerances = tolerances;
m_provider.PeakMatcher = stanleyMatcher;
}
/// <summary>
/// Default constructor for a MultiAlign analysis object.
/// </summary>
public MultiAlignAnalysis()
{
// Meta Data Information about the analysis and datasets.
MetaData = new AnalysisMetaData {
AnalysisName = string.Empty
};
Options = new MultiAlignAnalysisOptions();
MassTagDatabase = new MassTagDatabase();
// Alignment options and data.
AlignmentData = new List <AlignmentData>();
MatchResults = null;
}
/// <summary>
/// Reset the settings the default values
/// </summary>
public void RestoreDefaults()
{
var defaultOptions = new MultiAlignAnalysisOptions();
this.MassResolution = defaultOptions.InstrumentTolerances.Mass;
this.FragmentationTolerance = defaultOptions.InstrumentTolerances.FragmentationWindowSize;
this.MinimumMz = defaultOptions.MsFilteringOptions.MzRange.Minimum;
this.MaximumMz = defaultOptions.MsFilteringOptions.MzRange.Maximum;
this.ShouldUseMzFilter = defaultOptions.MsFilteringOptions.ShouldUseMzFilter;
this.MinimumCharge = defaultOptions.MsFilteringOptions.ChargeRange.Minimum;
this.MaximumCharge = defaultOptions.MsFilteringOptions.ChargeRange.Maximum;
this.ShouldUseChargeStateFilter = defaultOptions.MsFilteringOptions.ShouldUseChargeFilter;
this.FilterOnMinutes = defaultOptions.LcmsFilteringOptions.FilterOnMinutes;
this.MinimumFeatureLength = defaultOptions.LcmsFilteringOptions.FeatureLengthRangeMinutes.Minimum;
this.MaximumFeatureLength = defaultOptions.LcmsFilteringOptions.FeatureLengthRangeMinutes.Maximum;
this.MinimumFeatureLengthMinutes = this.MinimumFeatureLength;
this.MaximumFeatureLengthMinutes = this.MaximumFeatureLength;
this.MinimumFeatureLengthScans = defaultOptions.LcmsFilteringOptions.FeatureLengthRangeScans.Minimum;
this.MaximumFeatureLengthScans = defaultOptions.LcmsFilteringOptions.FeatureLengthRangeScans.Maximum;
this.MinimumFeatureDataPoints = defaultOptions.LcmsFilteringOptions.MinimumDataPoints;
this.MinimumDeisotopingScore = defaultOptions.MsFilteringOptions.MinimumDeisotopingScore;
this.ShouldUseDeisotopingFilter = defaultOptions.MsFilteringOptions.ShouldUseDeisotopingFilter;
this.MinimumIntensity = defaultOptions.MsFilteringOptions.MinimumIntensity;
this.ShouldUseIntensityFilter = defaultOptions.MsFilteringOptions.ShouldUseIntensityFilter;
this.FirstPassClusterer = defaultOptions.LcmsFindingOptions.FirstPassClusterer;
this.ShouldCreateXics = defaultOptions.LcmsFindingOptions.FindXics;
this.XicRelativeIntensityThreshold = defaultOptions.LcmsFindingOptions.XicRelativeIntensityThreshold;
this.ShouldRefineXics = defaultOptions.LcmsFindingOptions.RefineXics;
this.ShouldPerformSecondPassClustering = defaultOptions.LcmsFindingOptions.SecondPassClustering;
this.SecondPassClusterer = defaultOptions.LcmsFindingOptions.SecondPassClusterer;
this.SmoothingWindowSize = defaultOptions.LcmsFindingOptions.SmoothingWindowSize;
this.SmoothingPolynomialOrder = defaultOptions.LcmsFindingOptions.SmoothingPolynomialOrder;
}
/// <summary>
/// Reset the settings the default values
/// </summary>
public void RestoreDefaults()
{
var defaultOptions = new MultiAlignAnalysisOptions();
ShouldUseIsotopicFitFilter = defaultOptions.DataLoadOptions.UseIsotopicFitFilter;
MaximumIsotopicFit = defaultOptions.DataLoadOptions.MaximumIsotopicFit;
ShouldUseAbundance = defaultOptions.DataLoadOptions.UseAbundanceFilter;
MinimumAbundance = defaultOptions.DataLoadOptions.MinimumAbundance;
MaximumAbundance = defaultOptions.DataLoadOptions.MaximumAbundance;
ShouldUseLCScanFilter = defaultOptions.DataLoadOptions.UseLCScanFilter;
MinimumLCScan = defaultOptions.DataLoadOptions.MinimumLCScan;
MaximumLCScan = defaultOptions.DataLoadOptions.MaximumLCScan;
ShouldUseMaximumDataCountFilter = defaultOptions.DataLoadOptions.UseMaximumDataCountFilter;
MaximumPointsToLoad = defaultOptions.DataLoadOptions.MaximumPointsToLoad;
}
private void LoadExistingParameters()
{
try
{
//TODO: Replace with OOKI dialogs
var result = m_dialog.ShowDialog();
if (result != null && result.Value)
{
var reader = new JsonReader <MultiAlignAnalysisOptions>();
m_options = reader.Read(m_dialog.FileName);
UpdateOptions();
}
}
//TODO: Replace with appropriate exception handling
catch (Exception)
{
//TODO: Display the error
}
}
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>());
}
/// <summary>
/// Reset the settings the default values
/// </summary>
public void RestoreDefaults()
{
var defaultOptions = new MultiAlignAnalysisOptions();
this.ShouldAlignToAMT = defaultOptions.AlignmentOptions.AlignToAMT;
this.SelectedAlignmentAlgorithm = defaultOptions.AlignmentOptions.AlignmentAlgorithm;
this.SelectedCalibrationType = defaultOptions.AlignmentOptions.AlignmentType;
this.AlignmentContractionFactor = defaultOptions.AlignmentOptions.ContractionFactor;
this.AlignmentNumTimeSections = defaultOptions.AlignmentOptions.NumTimeSections;
this.MinObservationCount = defaultOptions.MassTagDatabaseOptions.MinimumObservationCountFilter;
this.DatabaseSelectionViewModel.MassTolerance = defaultOptions.LcmsClusteringOptions.InstrumentTolerances.Mass;
this.DatabaseSelectionViewModel.NetTolerance = defaultOptions.LcmsClusteringOptions.InstrumentTolerances.Net;
this.imageDpi = DefaultImageDpi;
this.imageWidth = DefaultImageWidth;
this.imageHeight = DefaultImageHeight;
}
public AnalysisOptionsViewModel(MultiAlignAnalysisOptions options)
{
m_options = options;
ClusteringAlgorithms = new ObservableCollection <LcmsFeatureClusteringAlgorithmType>();
AlignmentAlgorithms = new ObservableCollection <FeatureAlignmentType>();
FeatureFindingAlgorithms = new ObservableCollection <FeatureFinderType>();
UpdateOptions();
InstrumentPresets = new ObservableCollection <InstrumentPresetViewModel>();
ExperimentPresets = new ObservableCollection <ExperimentPresetViewModel>();
TimeOptions = new ObservableCollection <string>();
var presets = new Dictionary <string, bool>();
foreach (var preset in ExperimentPresetFactory.Create())
{
ExperimentPresets.Add(preset);
if (!presets.ContainsKey(preset.InstrumentPreset.Name))
{
presets.Add(preset.InstrumentPreset.Name, false);
InstrumentPresets.Add(preset.InstrumentPreset);
}
}
foreach (var preset in InstrumentPresetFactory.Create())
{
if (!presets.ContainsKey(preset.Name))
{
InstrumentPresets.Add(preset);
}
}
TimeOptions.Add("Minutes");
TimeOptions.Add("Scans");
SelectedPreset = InstrumentPresets[0];
SelectedExperimentPreset = ExperimentPresets[0];
TreatAsTimeOrScan = TimeOptions[0];
m_saveDialog = new SaveFileDialog();
m_dialog = new OpenFileDialog
{
Filter = Resources.MultiAlignParameterFileFilter
};
m_saveDialog.Filter = Resources.MultiAlignParameterFileFilter;
ShowAdvancedWindowCommand = new BaseCommand(ShowAdvancedWindow);
SaveOptionsCommand = new BaseCommand(SaveCurrentParameters);
LoadExistingCommand = new BaseCommand(LoadExistingParameters);
Enum.GetValues(typeof(LcmsFeatureClusteringAlgorithmType))
.Cast <LcmsFeatureClusteringAlgorithmType>()
.ToList()
.ForEach(x => ClusteringAlgorithms.Add(x));
Enum.GetValues(typeof(FeatureAlignmentType))
.Cast <FeatureAlignmentType>()
.ToList()
.ForEach(x => AlignmentAlgorithms.Add(x));
Enum.GetValues(typeof(FeatureFinderType))
.Cast <FeatureFinderType>()
.ToList()
.ForEach(x => FeatureFindingAlgorithms.Add(x));
}
