public AlignmentSettingsViewModel(MultiAlignAnalysis analysis,
FeatureLoader featureCache,
IAlignmentWindowFactory alignmentWindowFactory = null,
IProgress<int> progressReporter = null)
{
this.analysis = analysis;
this.featureCache = featureCache;
this.alignmentWindowFactory = alignmentWindowFactory ?? new AlignmentViewFactory();
this.progress = progressReporter ?? new Progress<int>();
this.aligner = new LCMSFeatureAligner();
this.builder = new AlgorithmBuilder();
this.CalibrationOptions = new ObservableCollection<AlignmentType>(Enum.GetValues(typeof(AlignmentType)).Cast<AlignmentType>());
this.AlignmentAlgorithms = new ObservableCollection<FeatureAlignmentType>(
Enum.GetValues(typeof(FeatureAlignmentType)).Cast<FeatureAlignmentType>());
this.selectedDatasets = new ReadOnlyCollection<DatasetInformationViewModel>(new List<DatasetInformationViewModel>());
this.alignmentInformation = new List<classAlignmentData>();
this.MessengerInstance.Register<PropertyChangedMessage<IReadOnlyCollection<DatasetInformationViewModel>>>(this, sds =>
{
this.selectedDatasets = sds.NewValue;
ThreadSafeDispatcher.Invoke(() => this.AlignToBaselineCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
});
this.AlignToBaselineCommand = new RelayCommand(this.AsyncAlignToBaseline, () => this.SelectedBaseline != null &&
this.selectedDatasets != null &&
this.selectedDatasets.Count > 0 &&
this.selectedDatasets.Any(file => !file.DoingWork));
this.DisplayAlignmentCommand = new RelayCommand(this.DisplayAlignment, () => this.selectedDatasets.Any(file => file.IsAligned));
}
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>();
}
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<DatasetInformationViewModel>(new List<DatasetInformationViewModel>());
this.msFeatureWindowFactory = new MSFeatureViewFactory();
this.MessengerInstance.Register<PropertyChangedMessage<IReadOnlyCollection<DatasetInformationViewModel>>>(this, sds =>
{
this.selectedDatasets = sds.NewValue;
this.FindMSFeaturesCommand.RaiseCanExecuteChanged();
this.PlotMSFeaturesCommand.RaiseCanExecuteChanged();
});
this.FindMSFeaturesCommand = new RelayCommand(
async () => await this.LoadMSFeaturesAsync(),
() => this.selectedDatasets != null &&
this.selectedDatasets.Count > 0 &&
this.selectedDatasets.Any(file => !file.DoingWork));
this.PlotMSFeaturesCommand = new RelayCommand(
async () => await this.PlotMSFeatures(),
() => this.selectedDatasets.Any(file => file.FeaturesFound));
}
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 (database.DatabaseName == null || database.DatabaseServer == null)
{
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;
}
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);
}
public void TestXMLParameterWriterDriftTimeAlignment(string path)
{
try
{
XMLParameterFileWriter writer = new XMLParameterFileWriter();
XMLParamterFileReader reader = new XMLParamterFileReader();
MultiAlignAnalysis analysis = new MultiAlignAnalysis();
analysis.Options.DriftTimeAlignmentOptions = ChangeObjectValues(analysis.Options.DriftTimeAlignmentOptions) as MultiAlignCore.Algorithms.Alignment.DriftTimeAlignmentOptions;
writer.WriteParameterFile(path, analysis);
MultiAlignAnalysis newAnalysis = new MultiAlignAnalysis();
reader.ReadParameterFile(path, ref newAnalysis);
Compare(analysis.Options.DriftTimeAlignmentOptions, newAnalysis.Options.DriftTimeAlignmentOptions);
}
catch (Exception ex)
{
throw;
}
finally
{
try
{
bool exists = File.Exists(path);
if (exists)
{
File.Delete(path);
}
}
catch
{
Console.WriteLine("The file was not deleted.");
}
}
}
public static FeatureDataAccessProviders CreateDataAccessProviders(MultiAlignAnalysis analysis,
bool deleteIfExists)
{
var path = AnalysisPathUtils.BuildAnalysisName(analysis.MetaData.AnalysisPath,
analysis.MetaData.AnalysisName);
return CreateDataAccessProviders(path, deleteIfExists);
}
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);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
m_config = new AnalysisConfig();
Analysis = new MultiAlignAnalysis();
m_config.AnalysisName = "Analysis.db3";
m_config.Analysis = Analysis;
this.WindowTitle = "MultiAlign Rogue";
DataSelectionViewModel = new AnalysisDatasetSelectionViewModel(Analysis);
SelectFilesCommand = new RelayCommand(SelectFiles, () => !string.IsNullOrWhiteSpace(this.ProjectPath));
SelectDirectoryCommand = new RelayCommand(SelectDirectory, () => !string.IsNullOrWhiteSpace(this.ProjectPath));
AddFolderCommand = new RelayCommand(AddFolderDelegate, () => !string.IsNullOrWhiteSpace(this.InputFilePath) && Directory.Exists(this.InputFilePath) && !string.IsNullOrWhiteSpace(this.ProjectPath));
SearchDmsCommand = new RelayCommand(SearchDms, () => this.ShowOpenFromDms && !string.IsNullOrWhiteSpace(this.ProjectPath));
CreateNewProjectCommand = new RelayCommand(this.CreateNewProject);
SaveProjectCommand = new RelayCommand(SaveProject, () => !string.IsNullOrWhiteSpace(this.ProjectPath));
LoadProjectCommand = new RelayCommand(LoadProject);
SaveAsProjectCommand = new RelayCommand(this.SaveProjectAs, () => !string.IsNullOrWhiteSpace(this.ProjectPath));
featureCache = new FeatureLoader { Providers = Analysis.DataProviders };
this.SelectedDatasets = new List<DatasetInformationViewModel>();
Datasets = new ObservableCollection<DatasetInformationViewModel>();
featureCache.Providers = Analysis.DataProviders;
this.FeatureFindingSettingsViewModel = new FeatureFindingSettingsViewModel(Analysis, featureCache);
this.AlignmentSettingsViewModel = new AlignmentSettingsViewModel(Analysis, featureCache);
this.ClusterSettingsViewModel = new ClusterSettingsViewModel(Analysis);
}
/// <summary>
/// Saves the analysis parameters to file.
/// </summary>
/// <param name="filename">File to save to.</param>
/// <param name="analysis">Analysis with options to save.</param>
public void WriteParametersToFile(string filename, MultiAlignAnalysis analysis)
{
using (TextWriter writer = File.CreateText(filename))
{
WriteOptionGroup(writer, ALIGNMENT_TAG, analysis.Options.AlignmentOptions);
WriteOptionGroup(writer, FEATURE_FINDING_TAG, analysis.Options.FeatureFindingOptions);
WriteOptionGroup(writer, MASS_TAG_DATABASE_TAG, analysis.Options.MassTagDatabaseOptions);
WriteOptionGroup(writer, CLUSTER_TAG, analysis.Options.ClusterOptions);
writer.WriteLine("[" + GLOBAL_TAG + "]" );
WriteOption(writer, GLOBAL_OPTION_USE_MTDB_AS_BASELINE, analysis.Options.AlignmentOptions.IsAlignmentBaselineAMasstagDB);
writer.WriteLine();
}
}
/// <summary>
///
/// </summary>
/// <param name="parameterFilePath"></param>
/// <returns></returns>
public void ReadParameterFile(string parameterFilePath, ref MultiAlignAnalysis analysis)
{
if (!File.Exists(parameterFilePath))
throw new FileNotFoundException("The parameter file was not found. " + parameterFilePath);
// Parse the data.
string[] lines = File.ReadAllLines(parameterFilePath);
ExtractGroups(lines);
LoadParameterOptions(ProcessSubSectionData(ALIGNMENT_TAG), analysis.Options.AlignmentOptions);
LoadParameterOptions(ProcessSubSectionData(FEATURE_FINDING_TAG), analysis.Options.FeatureFindingOptions);
LoadParameterOptions(ProcessSubSectionData(MASS_TAG_DATABASE_TAG), analysis.Options.MassTagDatabaseOptions);
LoadParameterOptions(ProcessSubSectionData(CLUSTER_TAG), analysis.Options.ClusterOptions);
LoadGlobalOptions(ref analysis);
}
public ClusterSettingsViewModel(MultiAlignAnalysis analysis, IProgress<int> progressReporter = null)
{
this.analysis = analysis;
this.options = analysis.Options;
this.builder = new AlgorithmBuilder();
this.ClusterFeaturesCommand = new RelayCommand(this.AsyncClusterFeatures);
this.DisplayClustersCommand = new RelayCommand(this.DisplayFeatures);
this.DistanceMetrics = new ObservableCollection<DistanceMetric>();
Enum.GetValues(typeof(DistanceMetric)).Cast<DistanceMetric>().ToList().ForEach(x => this.DistanceMetrics.Add(x));
this.CentroidRepresentations = new ObservableCollection<ClusterCentroidRepresentation>();
Enum.GetValues(typeof(ClusterCentroidRepresentation)).Cast<ClusterCentroidRepresentation>().ToList().ForEach(x => this.CentroidRepresentations.Add(x));
this.ClusteringMethods = new ObservableCollection<LcmsFeatureClusteringAlgorithmType>();
Enum.GetValues(typeof(LcmsFeatureClusteringAlgorithmType)).Cast<LcmsFeatureClusteringAlgorithmType>().ToList().ForEach(x => this.ClusteringMethods.Add(x));
}
/// <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 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 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);
}
/// <summary>
/// Constructs dataset infromation from the input analysis information.
/// </summary>
private void ConstructDatasetInformation(InputAnalysisInfo analysisSetupInformation, MultiAlignAnalysis analysis,
bool insertIntoDatabase)
{
// Create dataset information.
Logger.PrintMessage("Creating dataset and other input information.");
var datasets = DatasetInformation.CreateDatasetsFromInputFile(analysisSetupInformation.Files);
analysis.MetaData.Datasets.AddRange(datasets);
if (insertIntoDatabase)
{
m_config.Analysis.DataProviders.DatasetCache.AddAll(datasets);
}
}
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>
/// Constructor.
/// </summary>
/// <param name="analysis"></param>
public AnalysisCompleteEventArgs(MultiAlignAnalysis analysis)
{
Analysis = analysis;
}
/// <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();
}
* */
}
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);
}
private MultiAlignAnalysis ConstructAnalysisObject(InputAnalysisInfo analysisSetupInformation)
{
Logger.PrintMessage("Creating Analysis Objects.");
var analysis = new MultiAlignAnalysis
{
MetaData = { AnalysisPath = m_config.AnalysisPath, AnalysisName = m_config.AnalysisName }
};
analysis.Options.AlignmentOptions.IsAlignmentBaselineAMasstagDB = true;
analysis.MetaData.ParameterFile = m_config.ParameterFile;
analysis.MetaData.InputFileDefinition = m_config.InputPaths;
analysis.MetaData.AnalysisSetupInfo = analysisSetupInformation;
return analysis;
}
/// <summary>
/// Loads the global options manually.
/// </summary>
/// <param name="analysis"></param>
private void LoadGlobalOptions(ref MultiAlignAnalysis analysis)
{
Dictionary<string, string> map = ProcessSubSectionData(GLOBAL_TAG);
analysis.Options.AlignmentOptions.IsAlignmentBaselineAMasstagDB = Convert.ToBoolean(map["Use Mass Tag DB As Baseline"]);
}
public AnalysisStatusArgs(MultiAlignAnalysis analysis)
{
Analysis = analysis;
}
/// <summary>
///
/// </summary>
/// <param name="parameterFilePath"></param>
/// <returns></returns>
public void ReadParameterFile(string parameterFilePath, ref MultiAlignAnalysis analysis)
{
AnalysisOptions options = analysis.Options;
ReadParameterFile(parameterFilePath, ref options);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="analysis"></param>
public AnalysisCompleteEventArgs(MultiAlignAnalysis analysis)
{
Analysis = analysis;
}
public void WriteParameterFile(string parameterFilePath, MultiAlignAnalysis analysis)
{
WriteParameterFile(parameterFilePath, analysis.Options);
}
/// <summary>
/// Writes the parameters to the log file and database.
/// </summary>
private void PrintParameters(MultiAlignAnalysis analysis, bool insertIntoDatabase)
{
Logger.PrintMessage("Parameters Loaded");
var options = new Dictionary<string, object>
{
{"Instrument Tolerances", analysis.Options.InstrumentTolerances},
{"Ms Feature Filtering Options", analysis.Options.MsFilteringOptions},
{"Feature Filtering Options", analysis.Options.LcmsFilteringOptions},
{"Mass Tag Database Options", analysis.Options.MassTagDatabaseOptions},
{"Alignment Options", analysis.Options.AlignmentOptions},
{"Clustering Options", analysis.Options.LcmsClusteringOptions},
{"STAC Options", analysis.Options.StacOptions}
};
var allmappings = new List<ParameterHibernateMapping>();
foreach (var key in options.Keys)
{
//var o = options[key];
Logger.PrintMessage(key, true);
//var parameters = ParameterUtility.ConvertParameterObjectToStrings(o);
//foreach (var parameter in parameters)
//{
// Logger.PrintMessage("\t" + parameter, true);
//}
//var mappings = ParameterUtility.ExtractParameterMapObjects(o, key);
//allmappings.AddRange(mappings);
}
var assemblyData = ApplicationUtility.GetAssemblyData();
var assemblyMap = new ParameterHibernateMapping
{
OptionGroup = "Assembly Info",
Parameter = "Version",
Value = assemblyData
};
allmappings.Add(assemblyMap);
var systemData = ApplicationUtility.GetSystemData();
var systemMap = new ParameterHibernateMapping
{
OptionGroup = "Assembly Info",
Parameter = "System Info",
Value = systemData
};
allmappings.Add(systemMap);
if (insertIntoDatabase)
{
Logger.PrintMessage("Writing parameters to the analysis database.");
var parameterCache = new GenericDAOHibernate<ParameterHibernateMapping>();
parameterCache.AddAll(allmappings);
}
}
