CreateDatasetAligner(FeatureAlignmentType type,
LcmsWarpAlignmentOptions options,
SpectralOptions spectralOptions)
{
IFeatureAligner <IEnumerable <UMCLight>, IEnumerable <UMCLight>, AlignmentData> aligner = null;
switch (type)
{
case FeatureAlignmentType.LCMS_WARP:
aligner = new LcmsWarpFeatureAligner(options);
break;
case FeatureAlignmentType.DIRECT_IMS_INFUSION:
aligner = new DummyAlignment();
break;
case FeatureAlignmentType.SPECTRAL_ALIGNMENT:
aligner = new SpectralAlignerWrapper {
Options = spectralOptions, Bandwidth = Bandwidth
};
break;
}
return(aligner);
}
/// <summary>
/// Default constructor, initializes every value to commonly used values and flags
/// </summary>
public LcmsWarpAlignmentOptions()
{
NumTimeSections = 100;
TopFeatureAbundancePercent = 0;
ContractionFactor = 3;
MaxTimeDistortion = 10;
MaxPromiscuity = 3;
UsePromiscuousPoints = false;
MassCalibUseLsq = false;
MassCalibrationWindow = 6.0;
MassCalibNumXSlices = 12;
MassCalibNumYSlices = 50;
MassCalibMaxJump = 20;
MassCalibMaxZScore = 3;
MassCalibLsqMaxZScore = 2.5;
MassCalibLsqNumKnots = 12;
MassTolerance = 6.0;
NetTolerance = 0.03;
AlignType = AlignmentType.NET_MASS_WARP;
CalibrationType = LcmsWarpCalibrationType.Both;
AlignToMassTagDatabase = false;
MassBinSize = 0.2;
NetBinSize = 0.001;
DriftTimeBinSize = 0.03;
StoreAlignmentFunction = false;
AlignmentAlgorithmType = FeatureAlignmentType.LCMS_WARP;
}
public static IFeatureAligner<IEnumerable<UMCLight>, IEnumerable<UMCLight>, classAlignmentData> CreateDatasetAligner(FeatureAlignmentType type,
LcmsWarpAlignmentOptions options,
SpectralOptions spectralOptions)
{
IFeatureAligner<IEnumerable<UMCLight>, IEnumerable<UMCLight>, classAlignmentData> aligner = null;
switch (type)
{
case FeatureAlignmentType.LCMS_WARP:
aligner = new LcmsWarpFeatureAligner {Options = options};
break;
case FeatureAlignmentType.DIRECT_IMS_INFUSION:
aligner = new DummyAlignment();
break;
case FeatureAlignmentType.SPECTRAL_ALIGNMENT:
aligner = new SpectralAlignerWrapper {Options = spectralOptions, Bandwidth = Bandwidth};
break;
}
return aligner;
}
public void GenerateClusterAlignmentStatistics(string relativeDatabasePath,
string relativeName,
string name,
FeatureAlignmentType alignmentType,
LcmsFeatureClusteringAlgorithmType clusterType)
{
var databasePath = GetPath(relativeDatabasePath);
var outputPath = GetOutputPath(relativeName);
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
// Connect to the NHibernate database
var providers = DataAccessFactory.CreateDataAccessProviders(databasePath, false);
// Setup our alignment options
var alignmentOptions = new AlignmentOptions();
var spectralOptions = new SpectralOptions
{
ComparerType = SpectralComparison.CosineDotProduct,
Fdr = .01,
IdScore = 1e-09,
MzBinSize = .5,
MzTolerance = .5,
NetTolerance = .1,
RequiredPeakCount = 32,
SimilarityCutoff = .75,
TopIonPercent = .8
};
// Options setup
var instrumentOptions = InstrumentPresetFactory.Create(InstrumentPresets.LtqOrbitrap);
var featureTolerances = new FeatureTolerances
{
Mass = instrumentOptions.Mass + 6,
Net = instrumentOptions.NetTolerance,
DriftTime = instrumentOptions.DriftTimeTolerance
};
UpdateStatus("Retrieving all datasets for test.");
var datasets = providers.DatasetCache.FindAll();
// Create our algorithms
var aligner = FeatureAlignerFactory.CreateDatasetAligner(alignmentType,
alignmentOptions.LCMSWarpOptions,
spectralOptions);
var clusterer = ClusterFactory.Create(clusterType);
clusterer.Parameters = new FeatureClusterParameters<UMCLight>
{
Tolerances = featureTolerances
};
RegisterProgressNotifier(aligner);
RegisterProgressNotifier(clusterer);
for (var i = 0; i < datasets.Count - 1; i++)
{
var matchPath = string.Format("{0}-{1}-matches.txt", name, i);
var errorPath = string.Format("{0}-{1}-errors.txt", name, i);
matchPath = Path.Combine(outputPath, matchPath);
errorPath = Path.Combine(outputPath, errorPath);
var aligneeDataset = datasets[i + 1];
var baselineDataset = datasets[i];
// Load the baseline reference set
using (var rawProviderX = RawLoaderFactory.CreateFileReader(baselineDataset.RawPath))
{
rawProviderX.AddDataFile(baselineDataset.RawPath, 0);
// Load the baseline reference set
using (var rawProviderY = RawLoaderFactory.CreateFileReader(aligneeDataset.RawPath))
{
rawProviderY.AddDataFile(aligneeDataset.RawPath, 0);
var baselineFeatures = RetrieveFeatures(baselineDataset.DatasetId, providers);
var aligneeFeatures = RetrieveFeatures(aligneeDataset.DatasetId, providers);
var providerX = new CachedFeatureSpectraProvider(rawProviderX, baselineFeatures);
var providerY = new CachedFeatureSpectraProvider(rawProviderY, aligneeFeatures);
AlignDatasets( baselineFeatures,
aligneeFeatures,
providerX,
providerY,
aligner,
clusterer,
matchPath,
errorPath);
}
}
}
}
public void TestClustering(
string directory,
string outputPath,
FeatureAlignmentType alignmentType,
LcmsFeatureClusteringAlgorithmType clusterType)
{
var matchPath = string.Format("{0}.txt", outputPath);
var errorPath = string.Format("{0}-errors.txt", outputPath);
// Loads the supported MultiAlign types
var supportedTypes = DatasetLoader.SupportedFileTypes;
var extensions = new List <string>();
supportedTypes.ForEach(x => extensions.Add("*" + x.Extension));
// Find our datasets
var datasetLoader = new DatasetLoader();
var datasets = datasetLoader.GetValidDatasets(directory, extensions, SearchOption.TopDirectoryOnly);
// Setup our alignment options
var alignmentOptions = new AlignmentOptions();
var spectralOptions = new SpectralOptions
{
ComparerType = SpectralComparison.CosineDotProduct,
Fdr = .01,
IdScore = 1e-09,
MzBinSize = .5,
MzTolerance = .5,
NetTolerance = .1,
RequiredPeakCount = 32,
SimilarityCutoff = .75,
TopIonPercent = .8
};
// Options setup
var instrumentOptions = InstrumentPresetFactory.Create(InstrumentPresets.LtqOrbitrap);
var featureTolerances = new FeatureTolerances
{
Mass = instrumentOptions.Mass + 6,
Net = instrumentOptions.NetTolerance,
DriftTime = instrumentOptions.DriftTimeTolerance
};
var featureFindingOptions = new LcmsFeatureFindingOptions(featureTolerances)
{
MaximumNetRange = .002,
MaximumScanRange = 50
};
// Create our algorithms
var finder = FeatureFinderFactory.CreateFeatureFinder(FeatureFinderType.TreeBased);
var aligner = FeatureAlignerFactory.CreateDatasetAligner(alignmentType,
alignmentOptions.LCMSWarpOptions,
spectralOptions);
var clusterer = ClusterFactory.Create(clusterType);
clusterer.Parameters = new FeatureClusterParameters <UMCLight>
{
Tolerances = featureTolerances
};
RegisterProgressNotifier(aligner);
RegisterProgressNotifier(finder);
RegisterProgressNotifier(clusterer);
var lcmsFilters = new LcmsFeatureFilteringOptions
{
FeatureLengthRangeScans = new FilterRange(50, 300)
};
var msFilterOptions = new MsFeatureFilteringOptions
{
MinimumIntensity = 5000,
ChargeRange = new FilterRange(1, 6),
ShouldUseChargeFilter = true,
ShouldUseDeisotopingFilter = true,
ShouldUseIntensityFilter = true
};
for (var i = 0; i < 1; i++)
{
var aligneeDatasets = datasets.Where((t, j) => j != i).ToList();
PerformMultiAlignAnalysis(datasets[0],
aligneeDatasets,
featureFindingOptions,
msFilterOptions,
lcmsFilters,
spectralOptions,
finder,
aligner,
clusterer,
matchPath,
errorPath);
}
}
public void GenerateClusterAlignmentStatistics(string relativeDatabasePath,
string relativeName,
string name,
FeatureAlignmentType alignmentType,
LcmsFeatureClusteringAlgorithmType clusterType)
{
var databasePath = GetPath(relativeDatabasePath);
var outputPath = GetOutputPath(relativeName);
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
// Connect to the NHibernate database
var providers = DataAccessFactory.CreateDataAccessProviders(databasePath, false);
// Setup our alignment options
var alignmentOptions = new AlignmentOptions();
var spectralOptions = new SpectralOptions
{
ComparerType = SpectralComparison.CosineDotProduct,
Fdr = .01,
IdScore = 1e-09,
MzBinSize = .5,
MzTolerance = .5,
NetTolerance = .1,
RequiredPeakCount = 32,
SimilarityCutoff = .75,
TopIonPercent = .8
};
// Options setup
var instrumentOptions = InstrumentPresetFactory.Create(InstrumentPresets.LtqOrbitrap);
var featureTolerances = new FeatureTolerances
{
Mass = instrumentOptions.Mass + 6,
Net = instrumentOptions.NetTolerance,
DriftTime = instrumentOptions.DriftTimeTolerance
};
UpdateStatus("Retrieving all datasets for test.");
var datasets = providers.DatasetCache.FindAll();
// Create our algorithms
var aligner = FeatureAlignerFactory.CreateDatasetAligner(alignmentType,
alignmentOptions.LCMSWarpOptions,
spectralOptions);
var clusterer = ClusterFactory.Create(clusterType);
clusterer.Parameters = new FeatureClusterParameters <UMCLight>
{
Tolerances = featureTolerances
};
RegisterProgressNotifier(aligner);
RegisterProgressNotifier(clusterer);
for (var i = 0; i < datasets.Count - 1; i++)
{
var matchPath = string.Format("{0}-{1}-matches.txt", name, i);
var errorPath = string.Format("{0}-{1}-errors.txt", name, i);
matchPath = Path.Combine(outputPath, matchPath);
errorPath = Path.Combine(outputPath, errorPath);
var aligneeDataset = datasets[i + 1];
var baselineDataset = datasets[i];
// Load the baseline reference set
using (var rawProviderX = new InformedProteomicsReader())
{
rawProviderX.AddDataFile(baselineDataset.RawFile.Path, 0);
// Load the baseline reference set
using (var rawProviderY = new InformedProteomicsReader())
{
rawProviderY.AddDataFile(aligneeDataset.RawFile.Path, 0);
var baselineFeatures = RetrieveFeatures(baselineDataset.DatasetId, providers);
var aligneeFeatures = RetrieveFeatures(aligneeDataset.DatasetId, providers);
var providerX = new CachedFeatureSpectraProvider(rawProviderX, baselineFeatures);
var providerY = new CachedFeatureSpectraProvider(rawProviderY, aligneeFeatures);
AlignDatasets(baselineFeatures,
aligneeFeatures,
providerX,
providerY,
aligner,
clusterer,
matchPath,
errorPath);
}
}
}
}
public void TestClustering(
string directory,
string outputPath,
FeatureAlignmentType alignmentType,
LcmsFeatureClusteringAlgorithmType clusterType)
{
var matchPath = string.Format("{0}.txt", outputPath);
var errorPath = string.Format("{0}-errors.txt", outputPath);
// Loads the supported MultiAlign types
var supportedTypes = DatasetInformation.SupportedFileTypes;
var extensions = new List<string>();
supportedTypes.ForEach(x => extensions.Add("*" + x.Extension));
// Find our datasets
var inputFiles = DatasetSearcher.FindDatasets(directory,
extensions,
SearchOption.TopDirectoryOnly);
var datasets = DatasetInformation.ConvertInputFilesIntoDatasets(inputFiles);
// Setup our alignment options
var alignmentOptions = new AlignmentOptions();
var spectralOptions = new SpectralOptions
{
ComparerType = SpectralComparison.CosineDotProduct,
Fdr = .01,
IdScore = 1e-09,
MzBinSize = .5,
MzTolerance = .5,
NetTolerance = .1,
RequiredPeakCount = 32,
SimilarityCutoff = .75,
TopIonPercent = .8
};
// Options setup
var instrumentOptions = InstrumentPresetFactory.Create(InstrumentPresets.LtqOrbitrap);
var featureTolerances = new FeatureTolerances
{
Mass = instrumentOptions.Mass + 6,
Net = instrumentOptions.NetTolerance,
DriftTime = instrumentOptions.DriftTimeTolerance
};
var featureFindingOptions = new LcmsFeatureFindingOptions(featureTolerances)
{
MaximumNetRange = .002,
MaximumScanRange = 50
};
// Create our algorithms
var finder = FeatureFinderFactory.CreateFeatureFinder(FeatureFinderType.TreeBased);
var aligner = FeatureAlignerFactory.CreateDatasetAligner(alignmentType,
alignmentOptions.LCMSWarpOptions,
spectralOptions);
var clusterer = ClusterFactory.Create(clusterType);
clusterer.Parameters = new FeatureClusterParameters<UMCLight>
{
Tolerances = featureTolerances
};
RegisterProgressNotifier(aligner);
RegisterProgressNotifier(finder);
RegisterProgressNotifier(clusterer);
var lcmsFilters = new LcmsFeatureFilteringOptions
{
FeatureLengthRange = new FilterRange(50, 300)
};
var msFilterOptions = new MsFeatureFilteringOptions
{
MinimumIntensity = 5000,
ChargeRange = new FilterRange(1, 6),
ShouldUseChargeFilter = true,
ShouldUseDeisotopingFilter = true,
ShouldUseIntensityFilter = true
};
for (var i = 0; i < 1; i++)
{
var aligneeDatasets = datasets.Where((t, j) => j != i).ToList();
PerformMultiAlignAnalysis(datasets[0],
aligneeDatasets,
featureFindingOptions,
msFilterOptions,
lcmsFilters,
spectralOptions,
finder,
aligner,
clusterer,
matchPath,
errorPath);
}
}
