public void LoadWithoutDriftTime(string server, string databaseName)
{
var analysis = new MultiAlignAnalysis();
analysis.Options.MassTagDatabaseOptions.OnlyLoadTagsWithDriftTime = false;
analysis.MetaData.Database = new InputDatabase(MassTagDatabaseFormat.MassTagSystemSql)
{
DatabaseServer = server,
DatabaseName = databaseName
};
MassTagDatabaseLoader loader = new MtsMassTagDatabaseLoader(databaseName, server,
analysis.Options.MassTagDatabaseOptions);
var database = loader.LoadDatabase();
MassTagDatabaseLoader loader2 = new MtsMassTagDatabaseLoader(databaseName, server,
analysis.Options.MassTagDatabaseOptions);
loader2.Options.OnlyLoadTagsWithDriftTime = true;
var database2 = loader.LoadDatabase();
Assert.Greater(database.MassTags.Count, database2.MassTags.Count);
}
public void TestXMLParameterWriterFeatureFinderOptions(string path)
{
try
{
XMLParameterFileWriter writer = new XMLParameterFileWriter();
XMLParamterFileReader reader = new XMLParamterFileReader();
MultiAlignAnalysis analysis = new MultiAlignAnalysis();
analysis.Options.AlignmentOptions.IsAlignmentBaselineAMasstagDB = true;
analysis.Options.FeatureFindingOptions = ChangeObjectValues(analysis.Options.FeatureFindingOptions) as MultiAlignCore.Algorithms.FeatureFinding.LCMSFeatureFindingOptions;
writer.WriteParameterFile(path, analysis);
MultiAlignAnalysis newAnalysis = new MultiAlignAnalysis();
reader.ReadParameterFile(path, ref newAnalysis);
Compare(analysis.Options.FeatureFindingOptions, newAnalysis.Options.FeatureFindingOptions);
}
catch (Exception ex)
{
throw;
}
finally
{
try
{
bool exists = File.Exists(path);
if (exists)
{
File.Delete(path);
}
}
catch
{
Console.WriteLine("The file was not deleted.");
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="analysis"></param>
public DataLoadingSettingsViewModel(
MultiAlignAnalysis analysis)
{
this.analysis = analysis;
this.RestoreDefaultsCommand = new RelayCommand(this.RestoreDefaults);
}
public void TestXMLParameterWriterMTDB(string path)
{
try
{
XMLParameterFileWriter writer = new XMLParameterFileWriter();
XMLParamterFileReader reader = new XMLParamterFileReader();
MultiAlignAnalysis analysis = new MultiAlignAnalysis();
analysis.Options.MassTagDatabaseOptions = ChangeObjectValues(analysis.Options.MassTagDatabaseOptions) as MultiAlignCore.IO.MTDB.MassTagDatabaseOptions;
writer.WriteParameterFile(path, analysis);
MultiAlignAnalysis newAnalysis = new MultiAlignAnalysis();
reader.ReadParameterFile(path, ref newAnalysis);
Compare(analysis.Options.MassTagDatabaseOptions, newAnalysis.Options.MassTagDatabaseOptions);
}
catch (Exception ex)
{
throw;
}
finally
{
try
{
bool exists = File.Exists(path);
if (exists)
{
File.Delete(path);
}
}
catch
{
Console.WriteLine("The file was not deleted.");
}
}
}
private void LoadDatasets(MultiAlignAnalysis analysis)
{
var datasets = analysis.MetaData.Datasets.ToList();
// Sort the datasets for the view...
datasets.Sort(delegate(DatasetInformation x, DatasetInformation y)
{
if (x.DatasetId == y.DatasetId)
{
return(0);
}
if (x.IsBaseline)
{
return(-1);
}
return(x.DatasetName.CompareTo(y.DatasetName));
});
// Make the dataset plots.
var plotPath = Path.Combine(analysis.MetaData.AnalysisPath, "plots");
if (Directory.Exists(plotPath))
{
var loader = new DatasetPlotLoader();
loader.LoadDatasetPlots(plotPath, analysis.MetaData.Datasets.ToList());
}
Datasets = new DatasetCollectionViewModel(datasets);
}
public FeatureFindingSettingsViewModel(
MultiAlignAnalysis analysis,
FeatureLoader featureCache,
IFeatureWindowFactory msFeatureWindowFactory = null,
IProgress <int> progressReporter = null)
{
this.analysis = analysis;
this.featureCache = featureCache;
this.msFeatureWindowFactory = msFeatureWindowFactory ?? new MSFeatureViewFactory();
this.progress = progressReporter ?? new Progress <int>();
this.selectedDatasets = new ReadOnlyCollection <DatasetInformation>(new List <DatasetInformation>());
this.msFeatureWindowFactory = new MSFeatureViewFactory();
MessengerInstance.Register <PropertyChangedMessage <IReadOnlyCollection <DatasetInformation> > >(this, sds =>
{
this.selectedDatasets = sds.NewValue;
this.FindMSFeaturesCommand.RaiseCanExecuteChanged();
this.PlotMSFeaturesCommand.RaiseCanExecuteChanged();
});
FindMSFeaturesCommand = new RelayCommand(
async() => await LoadMSFeaturesAsync(),
() => this.selectedDatasets != null &&
this.selectedDatasets.Count > 0 &&
this.selectedDatasets.Any(file => !file.DoingWork));
PlotMSFeaturesCommand = new RelayCommand(
async() => await PlotMSFeatures(),
() => this.selectedDatasets.Any(file => file.FeaturesFound));
}
public AnalysisBaselineSelectionViewModel(MultiAlignAnalysis analysis)
{
var filter =
"Mass Tag Database (.db3)|*.db3|Direct Infusion IMS Database (.dims)|*.dims|All Files (*.*)|*.*";
m_analysis = analysis;
IsDatabaseDms = false;
IsDatabaseLocal = false;
IsBaselineDataset = true;
SetDatabaseToDms = new BaseCommand(SetDatabaseToDmsDelegate, BaseCommand.AlwaysPass);
SetDatabaseToLocal = new BaseCommand(SetDatabaseToLocalDelegate, BaseCommand.AlwaysPass);
SetBaselineToDatabase = new BaseCommand(SetBaselineToDatabaseDelegate, BaseCommand.AlwaysPass);
SetBaselineToDataset = new BaseCommand(SetBaselineToDatasetDelegate, BaseCommand.AlwaysPass);
FindLocalDatabase = new BrowseOpenFileCommand(x =>
{
DatabaseFilePath = x;
IsDatabaseLocal = true;
OnPropertyChanged("RequiresDatabaseSelection");
}, filter);
FindDmsDatabase = new BaseCommand(FindDmsDatabaseDelegate, BaseCommand.AlwaysPass);
ClearDatabase = new BaseCommand(ClearDatabaseDelegate, BaseCommand.AlwaysPass);
Datasets = new ObservableCollection <DatasetInformationViewModel>();
UpdateDatasets();
StacOptionsViewModel = new StacOptionsViewModel(analysis.Options.StacOptions);
MassTagDatabaseOptionsViewModel =
new MassTagDatabaseOptionsViewModel(analysis.Options.MassTagDatabaseOptions);
}
public static FeatureDataAccessProviders CreateDataAccessProviders(MultiAlignAnalysis analysis,
bool deleteIfExists)
{
var path = AnalysisPathUtils.BuildAnalysisName(analysis.MetaData.AnalysisPath,
analysis.MetaData.AnalysisName);
return(CreateDataAccessProviders(path, deleteIfExists));
}
/// <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);
}
private void DisplayAnalysis(MultiAlignAnalysis analysis)
{
// Change the title
var version = ApplicationUtility.GetEntryAssemblyData();
Title = string.Format("{0} - {1}", version, analysis.MetaData.AnalysisName);
var model = new AnalysisViewModel(analysis);
CurrentAnalysis = model;
StateModerator.CurrentViewState = ViewState.AnalysisView;
var recent = new RecentAnalysis(analysis.MetaData.AnalysisPath,
analysis.MetaData.AnalysisName);
GettingStartedViewModel.CurrentWorkspace.AddAnalysis(recent);
}
/// <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>());
}
public void OnlyLoadWithDriftTime(string server, string databaseName)
{
var analysis = new MultiAlignAnalysis();
analysis.Options.MassTagDatabaseOptions.OnlyLoadTagsWithDriftTime = true;
analysis.MetaData.Database = new InputDatabase(MassTagDatabaseFormat.MassTagSystemSql)
{
DatabaseServer = server,
DatabaseName = databaseName
};
var loader = new MTSMassTagDatabaseLoader(databaseName, server, analysis.Options.MassTagDatabaseOptions);
var database = loader.LoadDatabase();
foreach (var tag in database.MassTags)
{
Assert.IsTrue(tag.DriftTime > 0);
}
}
public AnalysisViewModel(MultiAlignAnalysis analysis)
{
m_showDriftTime = false;
LoadDatasets(analysis);
// Create matching clusters and AMT Matches.
var matches = analysis.DataProviders.MassTagMatches.FindAll();
var clusters =
analysis.Clusters.MapMassTagsToClusters(matches, analysis.MassTagDatabase);
// Cache the clusters so that they can be readily accessible later on.
// This will help speed up performance, so that we dont have to hit the database
// when we want to find matching mass tags, and dont have to map clusters to tags multiple times.
FeatureCacheManager <UMCClusterLightMatched> .SetFeatures(clusters.Item1);
FeatureCacheManager <MassTagToCluster> .SetFeatures(clusters.Item2);
SingletonDataProviders.Providers = analysis.DataProviders;
// Create sub-view models
MassTags = new ObservableCollection <MassTagToCluster>(clusters.Item2);
ClusterTree = new UmcClusterCollectionTreeViewModel(clusters.Item1);
ClusterSpectraViewModel = new UmcClusterSpectraViewModel();
ClusterIdentificationViewModel = new UMCClusterIdentificationViewModel();
AnalysisOptionsViewModel = new AnalysisOptionsViewModel(analysis.Options);
ClusterViewModel = new ClusterDetailViewModel();
var charges = SingletonDataProviders.Providers.FeatureCache.RetrieveChargeStates();
GlobalStatisticsViewModel = new GlobalStatisticsViewModel(clusters.Item1, charges);
HasIdentifications = (MassTags.Count > 0);
SelectedClusterName = "Cluster Details:";
LoadClusters(clusters.Item1);
ApplyViewAsFilter = new BaseCommand(FilterFromView);
}
/// <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));
}
public AnalysisDatasetSelectionViewModel(MultiAlignAnalysis analysis)
{
m_inputFileFilter = "Input Files (*.txt)| *.txt| All Files (*.*)|*.*";
m_featureFileFilter = DatasetFilterFactory.BuildFileFilters(InputFileType.Features);
m_openFileDialog = new OpenFileDialog {
Filter = m_inputFileFilter
};
m_analysis = analysis;
ShouldSearchSubDirectories = SearchOption.TopDirectoryOnly;
// Create The Dataset View Model for Binding
Datasets = new ObservableCollection <DatasetInformationViewModel>();
foreach (var information in analysis.MetaData.Datasets)
{
var info = new DatasetInformationViewModel(information);
info.Selected += info_Selected;
Datasets.Add(info);
}
// Route the events here...
AddFolderCommand = new BaseCommand(AddFolderDelegate, BaseCommand.AlwaysPass);
AddInputFileCommand = new BaseCommand(AddInputFileDelegate, BaseCommand.AlwaysPass);
AddSingleFileCommand = new BaseCommand(AddSingleFileDelegate, BaseCommand.AlwaysPass);
BrowseSingleFileCommand = new BaseCommand(BrowseSingleFile, BaseCommand.AlwaysPass);
BrowseInputFileCommand = new BaseCommand(BrowseInput, BaseCommand.AlwaysPass);
BrowseDataFolderCommand = new BrowseFolderCommand(x => { DataFolderPath = x; });
RemoveSelectedCommand = new BaseCommand(RemoveSelected, BaseCommand.AlwaysPass);
SelectAllCommand = new BaseCommand(SelectAllDelegate, BaseCommand.AlwaysPass);
SelectNoneCommand = new BaseCommand(SelectNoneDelegate, BaseCommand.AlwaysPass);
SelectedDatasets = new ObservableCollection <DatasetInformationViewModel>();
}
/// <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 AnalysisStatusArgs(MultiAlignAnalysis analysis)
{
Analysis = analysis;
}
private static bool ValidateBaseline(MultiAlignAnalysis analysis, ref string errorMessage)
{
var isStepValid = true;
if (analysis.Options.AlignmentOptions.IsAlignmentBaselineAMasstagDB)
{
var database = analysis.MetaData.Database;
var databasePath = analysis.MetaData.Database.DatabaseName;
switch (database.DatabaseFormat)
{
case MassTagDatabaseFormat.None:
errorMessage = "No database was selected.";
isStepValid = false;
break;
case MassTagDatabaseFormat.MassTagSystemSql:
if (string.IsNullOrWhiteSpace(database.DatabaseName) || string.IsNullOrWhiteSpace(database.DatabaseServer))
{
isStepValid = false;
errorMessage = "The database or server was not set.";
}
break;
case MassTagDatabaseFormat.SkipAlignment:
case MassTagDatabaseFormat.Sqlite:
databasePath = analysis.MetaData.Database.LocalPath;
if (databasePath == null)
{
errorMessage = "No MTDB database file was selected.";
isStepValid = false;
}
else
{
if (!File.Exists(databasePath))
{
errorMessage = "The database file provided does not exist.";
isStepValid = false;
}
}
break;
case MassTagDatabaseFormat.DelimitedTextFile:
errorMessage = "Invalid database type.";
isStepValid = false;
break;
}
}
else
{
if (analysis.MetaData.Datasets.Count < 2)
{
isStepValid = false;
errorMessage = "You must align a single dataset to a database.";
}
else if (analysis.MetaData.BaselineDataset == null)
{
errorMessage = "No baseline dataset was selected.";
isStepValid = false;
}
}
return(isStepValid);
}
/// <summary>
/// Writes a list of mamoth clusters back to the mass tag system at the server and database provided.
/// </summary>
/// <param name="server">Server the database exists on.</param>
/// <param name="database">Database to write results to.</param>
/// <param name="clusters">Clusters that are peak matched to.</param>
public void WriteClusters(MultiAlignAnalysis analysis,
List <UMCClusterLight> clusters,
string databasePath)
{
/*
* //clsMassTag[] massTagArray = analysis.PeakMatchingResults.marrMasstags;
* //clsProtein[] proteinArray = analysis.PeakMatchingResults.marrProteins;
* //List<clsMassTag> massTagList = new List<clsMassTag>();
* //List<clsProtein> proteinList = new List<clsProtein>();
* //List<ClusterToMassTagMap> clusterToMassTagMapList = new List<ClusterToMassTagMap>();
* //List<MassTagToProteinMap> massTagToProteinMapList = new List<MassTagToProteinMap>();
* //List<StacFDR> stacFDRResultsList = new List<StacFDR>();
* //Dictionary<int, int> clusterMatchDict = new Dictionary<int,int>(); // Unique matches to mass tags.
* //Dictionary<int, List<ClusterToMassTagMap>> clusterMassTagDict = new Dictionary<int, List<ClusterToMassTagMap>>();
* //Dictionary<double, int> stacFdrDict = new Dictionary<double,int>(); // counts number of matches with FDR's > key
* //double [] fdrScores = new double[] {.01, .05, .10, .25, .50};
*
* //foreach(int fdrCutoffScore in fdrScores)
* //{
* // stacFdrDict.Add(fdrCutoffScore, 0);
* //}
*
* //foreach (clsPeakMatchingResults.clsPeakMatchingTriplet triplet in analysis.PeakMatchingResults.marrPeakMatchingTriplet)
* //{
* // clsMassTag massTag = massTagArray[triplet.mintMassTagIndex];
* // clsProtein protein = proteinArray[triplet.mintProteinIndex];
* // ClusterToMassTagMap clusterToMassTagMap = new ClusterToMassTagMap(triplet.mintFeatureIndex, massTag.Id);
* // MassTagToProteinMap massTagToProteinMap = new MassTagToProteinMap(massTag.Id, protein.Id);
*
* // if (!clusterToMassTagMapList.Contains(clusterToMassTagMap))
* // {
* // clusterToMassTagMapList.Add(clusterToMassTagMap);
* // if (!clusterMatchDict.ContainsKey(triplet.mintFeatureIndex))
* // {
* // clusterMassTagDict.Add(triplet.mintFeatureIndex, new List<ClusterToMassTagMap>());
* // clusterMatchDict.Add(triplet.mintFeatureIndex, 1);
* // }
* // else
* // {
* // clusterMatchDict[triplet.mintFeatureIndex]++;
* // }
* // clusterMassTagDict[triplet.mintFeatureIndex].Add(clusterToMassTagMap);
*
* // if (analysis.STACResults != null)
* // {
* // // See if a SMART score exists
* // List<classSMARTProbabilityResult> smartScores = null;
* // smartScores = analysis.STACResults.GetResultFromUMCIndex(triplet.mintFeatureIndex);
*
* // if (smartScores != null)
* // {
* // // Then pull out the SMART score that matches for this triplet Mass Tag
* // classSMARTProbabilityResult finalResult = null;
* // foreach (classSMARTProbabilityResult score in smartScores)
* // {
* // if (score.MassTagID == massTag.Id)
* // {
* // finalResult = score;
* // break;
* // }
* // }
*
* // if (finalResult != null)
* // {
* // double score = finalResult.Score;
* // clusterToMassTagMap.StacScore = score;
* // clusterToMassTagMap.StacUP = finalResult.Specificity;
*
* // foreach(int fdrCutoffScore in fdrScores)
* // {
* // if (score <= fdrCutoffScore) stacFdrDict[score]++;
* // }
* // }
* // }
* // }
* // }
*
* // if (!massTagToProteinMapList.Contains(massTagToProteinMap)) massTagToProteinMapList.Add(massTagToProteinMap);
* // if (!massTagList.Contains(massTag)) massTagList.Add(massTag);
* // if (!proteinList.Contains(protein)) proteinList.Add(protein);
* //}
*
* //if (analysis.STACResults != null)
* //{
* // foreach (classSMARTFdrResult fdrResult in analysis.STACResults.GetSummaries())
* // {
* // stacFDRResultsList.Add(new StacFDR(fdrResult));
* // }
* //}
*
* //// find the minimum NET value for any cluster.
* //double minClusterNET = double.MaxValue;
* //double maxClusterNET = double.MinValue;
* //foreach(clsCluster cluster in clusters)
* //{
* // if (analysis.ClusterOptions.AlignClusters)
* // {
* // minClusterNET = Math.Min(minClusterNET, cluster.NetAligned);
* // maxClusterNET = Math.Max(maxClusterNET, cluster.NetAligned);
* // }
* // else
* // {
* // minClusterNET = Math.Min(minClusterNET, cluster.Net);
* // maxClusterNET = Math.Max(maxClusterNET, cluster.Net);
* // }
* //}
*
* // now write to the MTS System.
* string connectionString = "";
* string versionID = "";
* string parameters = "";
* string peakMatchingType = "1";
* int redundantCount = analysis.MatchResults.Matches.Count;
* int matchMakingID = -1;
*
* string parameterFile = "";
*
* if (analysis.MetaData.ParameterFile != null)
* {
* parameterFile = analysis.MetaData.ParameterFile;
* }
*
* using (IDbConnection connection = CreateConnection(connectionString))
* {
* connection.Open();
* using (IDbCommand command = connection.CreateCommand())
* {
* command.CommandType = System.Data.CommandType.StoredProcedure;
* command.Parameters.Add(CreateParameter("Reference_Job", analysis.MetaData.JobID));
* command.Parameters.Add(CreateParameter("File", peakMatchingType));
* command.Parameters.Add(CreateParameter("Type", 1));
* command.Parameters.Add(CreateParameter("Parameters", parameters));
* command.Parameters.Add(CreateParameter("PeaksCount", redundantCount));
*
* IDbDataParameter matchMakingParameter = CreateOutputParameter( "MatchMakingID",
* DbType.Int32,
* sizeof(int),
* 10,
* 0);
* command.Parameters.Add(matchMakingParameter);
* command.Parameters.Add(CreateParameter("ToolVersion", versionID));
* command.Parameters.Add(CreateParameter("ComparisonMassTagCount", analysis.MassTagDatabase.MassTags.Count));
* command.Parameters.Add(CreateParameter("UMCTolerancePPM", analysis.Options.FeatureFindingOptions.ConstraintMonoMass)); //TODO: do not necessarily have if using LCMS Feature Finder Data
* command.Parameters.Add(CreateParameter("UMCCount", clusters.Count));
* command.Parameters.Add(CreateParameter("NetAdjTolerancePPM", analysis.Options.AlignmentOptions.MassTolerance));
* command.Parameters.Add(CreateParameter("NetAdjUMCsHitCount", analysis.MatchResults.Matches.Count)); //TODO: is this right?
* command.Parameters.Add(CreateParameter("NetAdjTopAbuPct", 0)); // Per direction from Matt
* command.Parameters.Add(CreateParameter("NetAdjIterationCount", 1)); // Per direction from Matt
* command.Parameters.Add(CreateParameter("MMATolerancePPM", analysis.Options.STACOptions.MassTolerancePPM));
* command.Parameters.Add(CreateParameter("NETTolerance", analysis.Options.STACOptions.NETTolerance));
* command.Parameters.Add(CreateParameter("State", 2));
* command.Parameters.Add(CreateParameter("GANETFit", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("GANETSlope", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("GANETIntercept", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("NetAdjNetMin", minClusterNET));
* command.Parameters.Add(CreateParameter("NetAdjNetMax", maxClusterNET));
* command.Parameters.Add(CreateParameter("RefineMassCalPPMShift", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineMassCalPeakHeightCounts",0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineMassTolUsed", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineNETTolUsed", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("MinimumHighNormalizedScore", analysis.MassTagDBOptions.mfltMinXCorr));
* command.Parameters.Add(CreateParameter("MinimumPMTQualityScore", Convert.ToDouble(analysis.MassTagDBOptions.mdecimalMinPMTScore)));
* command.Parameters.Add(CreateParameter("IniFileName", parameterFile));
* command.Parameters.Add(CreateParameter("MinimumHighDiscriminantScore", analysis.MassTagDBOptions.mdblMinDiscriminant));
* command.Parameters.Add(CreateParameter("ExperimentFilter", analysis.MassTagDBOptions.mstrExperimentFilter));
* command.Parameters.Add(CreateParameter("ExperimentExclusionFilter", analysis.MassTagDBOptions.mstrExperimentExclusionFilter));
* command.Parameters.Add(CreateParameter("RefineMassCalPeakWidthPPM", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineMassCalPeakCenterPPM", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineNETTolPeakHeightCounts", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineNETTolPeakWidthNET", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("RefineNETTolPeakCenterNET", 0)); //TODO: do not have
* command.Parameters.Add(CreateParameter("LimitToPMTsFromDataset", 0));
* command.Parameters.Add(CreateParameter("MinimumPeptideProphetProbability", analysis.MassTagDBOptions.mdblPeptideProphetVal));
* command.Parameters.Add(CreateParameter("MatchScoreMode", Convert.ToInt32(analysis.PeakMatchingOptions.UseSTAC)));
* command.Parameters.Add(CreateParameter("STACUsedPriorProbability", Convert.ToInt32(analysis.STACOptions.UsePriorProbabilities)));
* command.Parameters.Add(CreateParameter("AMTCount1pctFDR", stacFdrDict[.01]));
* command.Parameters.Add(CreateParameter("AMTCount5pctFDR", stacFdrDict[.05]));
* command.Parameters.Add(CreateParameter("AMTCount10pctFDR", stacFdrDict[.10]));
* command.Parameters.Add(CreateParameter("AMTCount25pctFDR", stacFdrDict[.25]));
* command.Parameters.Add(CreateParameter("AMTCount50pctFDR", stacFdrDict[.50]));
* command.ExecuteNonQuery();
*
* matchMakingID = Convert.ToInt32(matchMakingParameter.Value);
* }
*
* using (IDbTransaction transaction = connection.BeginTransaction())
* {
* Dictionary<int, clsCluster> resultIDClusterMap = new Dictionary<int,clsCluster>();
*
* foreach (clsCluster cluster in clusters)
* {
* int matchCount = 0;
* int resultID = 0;
* if (clusterMatchDict.ContainsKey(cluster.Id))
* {
* matchCount = clusterMatchDict[cluster.Id];
* }
* using (IDbCommand command = connection.CreateCommand())
* {
* command.CommandType = CommandType.StoredProcedure;
* command.Parameters.Add(new SqlParameter("MDID", matchMakingID));
* command.Parameters.Add(new SqlParameter("UMCInd", cluster.Id));
* command.Parameters.Add(new SqlParameter("MemberCount", cluster.MemberCount));
* command.Parameters.Add(new SqlParameter("UMCScore", cluster.MeanScore));
* command.Parameters.Add(new SqlParameter("ScanFirst", -1));
* command.Parameters.Add(new SqlParameter("ScanLast", null));
* command.Parameters.Add(new SqlParameter("ScanMaxAbundance", null));
* command.Parameters.Add(new SqlParameter("ClassMass", cluster.Mass));
* command.Parameters.Add(new SqlParameter("MonoisotopicMassMin", null));
* command.Parameters.Add(new SqlParameter("MonoisotopicMassMax", null));
* command.Parameters.Add(new SqlParameter("MonoisotopicMassStDev", null));
* command.Parameters.Add(new SqlParameter("MonoisotopicMassMaxAbu", null));
* command.Parameters.Add(new SqlParameter("ClassAbundance", null));
* command.Parameters.Add(new SqlParameter("AbundanceMin", null));
* command.Parameters.Add(new SqlParameter("AbundanceMax", null));
* command.Parameters.Add(new SqlParameter("ChargeStateMin", null));
* command.Parameters.Add(new SqlParameter("ChargeStateMax", null));
* command.Parameters.Add(new SqlParameter("ChargeStateMaxAbu", null));
* command.Parameters.Add(new SqlParameter("FitAverage", null));
* command.Parameters.Add(new SqlParameter("FitMin", null));
* command.Parameters.Add(new SqlParameter("FitMax", null));
* command.Parameters.Add(new SqlParameter("FitStDev", null));
* command.Parameters.Add(new SqlParameter("ElutionTime", cluster.Net));
* command.Parameters.Add(new SqlParameter("ExpressionRatio", 0));
* command.Parameters.Add(new SqlParameter("PeakFPRType", 0));
* command.Parameters.Add(new SqlParameter("MassTagHitCount", matchCount));
* command.Parameters.Add(new SqlParameter("PairUMCInd", -1));
*
* SqlParameter idParameter = new SqlParameter("UMCResultsID",
* SqlDbType.Int,
* sizeof(int),
* System.Data.ParameterDirection.Output,
* false,
* 10,
* 0,
* "UMCResultsID",
* DataRowVersion.Current,
* resultID);
* command.Parameters.Add(idParameter);
* command.Parameters.Add(new SqlParameter("ClassStatsChargeBasis", null));
* command.Parameters.Add(new SqlParameter("GANETLockerCount", null));
* command.Parameters.Add(new SqlParameter("ExpressionRatioStDev", null));
* command.Parameters.Add(new SqlParameter("ExpressionRatioChargeStateBasisCount", null));
* command.Parameters.Add(new SqlParameter("ExpressionRatioMemberBasisCount", null));
* command.Parameters.Add(new SqlParameter("MemberCountUsedForAbu", cluster.MemberCount));
* command.Parameters.Add(new SqlParameter("DriftTime", cluster.DriftTime));
* command.ExecuteNonQuery();
*
* resultID = Convert.ToInt32(idParameter.Value);
* }
*
* if (matchCount > 0)
* {
* using (IDbCommand command = connection.CreateCommand())
* {
* double minScore = double.MaxValue;
* double maxScore = double.MinValue;
* double deltaMatchScore = 0;
*
* foreach(ClusterToMassTagMap massTagMap in clusterMassTagDict[cluster.Id])
* {
* minScore = Math.Min(minScore, massTagMap.StacScore);
* maxScore = Math.Max(maxScore, massTagMap.StacScore);
* }
* deltaMatchScore = Math.Abs(maxScore - minScore);
* foreach(ClusterToMassTagMap massTagMap in clusterMassTagDict[cluster.Id])
* {
* command.CommandType = CommandType.StoredProcedure;
* command.Parameters.Add(new SqlParameter("UMCResultsID", resultID));
* command.Parameters.Add(new SqlParameter("MassTagID", massTagMap.MassTagId));
* command.Parameters.Add(new SqlParameter("MatchingMemberCount", cluster.MemberCount));
* command.Parameters.Add(new SqlParameter("MatchScore", massTagMap.StacScore));
* command.Parameters.Add(new SqlParameter("MatchState", 6));
* command.Parameters.Add(new SqlParameter("SetIsConfirmedForMT", 1));
* command.Parameters.Add(new SqlParameter("MassTagMods", "N14"));
* command.Parameters.Add(new SqlParameter("MassTagModMass", 0));
* command.Parameters.Add(new SqlParameter("DelMatchScore", deltaMatchScore));
* command.Parameters.Add(new SqlParameter("UniquenessProbability", massTagMap.StacUP));
* command.Parameters.Add(new SqlParameter("FDRThreshold", 1));
* command.ExecuteNonQuery();
* }
* }
* }
* }
*
* List<classSMARTFdrResult> fdrList = analysis.STACResults.GetSummaries();
* if (fdrList != null)
* {
* foreach (classSMARTFdrResult fdr in fdrList)
* {
* using (IDbCommand command = connection.CreateCommand())
* {
* command.Parameters.Add(new SqlParameter("MDID", matchMakingID));
* command.Parameters.Add(new SqlParameter("STAC_Cutoff", fdr.Cutoff));
* command.Parameters.Add(new SqlParameter("UniqueAMTs", 0));
* command.Parameters.Add(new SqlParameter("FDR", fdr.FDR));
* command.Parameters.Add(new SqlParameter("Matches", fdr.NumMatches));
* command.Parameters.Add(new SqlParameter("Errors", fdr.Error));
* command.Parameters.Add(new SqlParameter("UPFilteredUniqueAMTs", 0));
* command.Parameters.Add(new SqlParameter("UPFilteredFDR", 0));
* command.Parameters.Add(new SqlParameter("UPFilteredMatches", 0));
* command.Parameters.Add(new SqlParameter("UPFilteredErrors", 0));
* command.ExecuteNonQuery();
* }
* }
* }
* transaction.Commit();
* }
* connection.Close();
* }
* */
}
