public void CalculateStatisticsTestNullUMC() { var cluster = new UMCClusterLight(); cluster.UmcList = null; Assert.Throws <NullReferenceException>(() => cluster.CalculateStatistics(ClusterCentroidRepresentation.Median)); }
public void CalculateStatisticsTestSingleUmc(double umcMass, double umcNet, float umcDriftTime, int umcCharge, int umcAbundance, ClusterCentroidRepresentation representation) { var cluster = new UMCClusterLight { UmcList = new List <UMCLight>() }; var umc = new UMCLight { MassMonoisotopicAligned = umcMass, Net = umcNet, DriftTime = umcDriftTime, ChargeState = umcCharge, Abundance = umcAbundance }; cluster.UmcList.Add(umc); cluster.CalculateStatistics(representation); Assert.AreEqual(umc.MassMonoisotopicAligned, cluster.MassMonoisotopic, "Monoisotopic Mass"); Assert.AreEqual(umc.Net, cluster.Net, "NET"); Assert.AreEqual(umc.DriftTime, cluster.DriftTime, "Drift Time"); Assert.AreEqual(umc.ChargeState, cluster.ChargeState, "Charge State"); }
public static void ExportMsMs(this UMCClusterLight cluster, string path, List <DatasetInformation> datasets, IMsMsSpectraWriter writer) { // Let's map the datasets first. var readers = new Dictionary <int, ISpectraProvider>(); var information = new Dictionary <int, DatasetInformation>(); datasets.ForEach(x => information.Add(x.DatasetId, x)); // We are only loading what datasets we have to here! // The point is, each cluster or feature may have come from a different raw data source... // since we dont store all of the data in memory, we have to fetch it from the appropriate source. // This means that we have to go into the raw data and get the scans for an MSMS spectra. foreach (var feature in cluster.Features) { if (!readers.ContainsKey(feature.GroupId)) { if (information.ContainsKey(feature.GroupId)) { var singleInfo = information[feature.GroupId]; if (singleInfo.RawFile != null) { // Make sure that we have a file. if (!File.Exists(singleInfo.RawFile.Path)) { continue; }
public void CalculateStatisticsTestNullUMC() { var cluster = new UMCClusterLight(); cluster.UmcList = null; cluster.CalculateStatistics(ClusterCentroidRepresentation.Median); }
public List <UMCClusterLight> CreateSingletonClustersFromClusteredFeatures(List <UMCClusterLight> clusters) { var newClusters = new List <UMCClusterLight>(); var i = 0; foreach (var cluster in clusters) { foreach (var feature in cluster.Features) { var x = new UMCClusterLight { MassMonoisotopic = feature.MassMonoisotopic, Net = feature.Net }; x.Net = feature.NetAligned; x.DriftTime = feature.DriftTime; x.ChargeState = feature.ChargeState; x.Id = i++; x.AddChildFeature(feature); newClusters.Add(x); } } return(newClusters); }
public void CalculateStatisticsMultipleNet(ClusterCentroidRepresentation representation) { var cluster = new UMCClusterLight(); cluster.UmcList = new List <UMCLight>(); var umc = new UMCLight(); umc.MassMonoisotopicAligned = 100; umc.Net = 100; umc.DriftTime = 100; umc.ChargeState = 2; umc.Abundance = 100; cluster.UmcList.Add(umc); var umc2 = new UMCLight(); umc2.MassMonoisotopicAligned = 100; umc2.Net = 200; umc2.DriftTime = 100; umc2.ChargeState = 2; umc2.Abundance = 100; cluster.UmcList.Add(umc2); cluster.CalculateStatistics(representation); Assert.AreEqual(150, cluster.Net); }
public void CalculateStatisticsTestEmptyUMC() { var cluster = new UMCClusterLight(); cluster.UmcList = new List <UMCLight>(); cluster.CalculateStatistics(ClusterCentroidRepresentation.Median); }
public void TestPairwise(string path) { Console.WriteLine("Test: " + path); var features = GetClusterData(Path.Combine(TestPathSingleton.TestDirectory, path)); Assert.IsNotEmpty(features); var cluster = new UMCClusterLight(); cluster.Id = features[0].Id; features.ForEach(x => cluster.AddChildFeature(x)); var distance = new EuclideanDistanceMetric <FeatureLight>(); for (var i = 0; i < features.Count; i++) { var featureX = features[i]; for (var j = 0; j < features.Count; j++) { if (i != j) { var featureY = features[j]; // Console.WriteLine(distance.EuclideanDistance(featureX, featureY)); } } } }
public void TestDatasets(string path) { Console.WriteLine("Test: " + path); var features = GetClusterData(Path.Combine(TestPathSingleton.TestDirectory, path)); Assert.IsNotEmpty(features); var cluster = new UMCClusterLight(); cluster.Id = features[0].Id; features.ForEach(x => cluster.AddChildFeature(x)); var maps = new Dictionary <int, UMCClusterLight>(); // Map the features var mapFeatures = new Dictionary <int, List <UMCLight> >(); foreach (var feature in features) { if (!mapFeatures.ContainsKey(feature.GroupId)) { mapFeatures.Add(feature.GroupId, new List <UMCLight>()); } mapFeatures[feature.GroupId].Add(feature); } Console.WriteLine("Cluster\tMass\tNET"); Console.WriteLine("{0}\t{1}\t{2}\t", cluster.Id, cluster.MassStandardDeviation, cluster.NetStandardDeviation); Console.WriteLine(); var distance = new EuclideanDistanceMetric <FeatureLight>(); //features.ForEach(x => Console.WriteLine(distance.EuclideanDistance(x, cluster))); }
public void CalculateStatisticsTestEmptyUMC() { var cluster = new UMCClusterLight(); cluster.UmcList = new List <UMCLight>(); Assert.Throws <Exception>(() => cluster.CalculateStatistics(ClusterCentroidRepresentation.Median)); }
/// <summary> /// Reconstruct the MS/MS for a cluster. /// Requires that the cluster's LCMS and MS features have been reconstructed. /// </summary> /// <param name="cluster">The cluster to reconstruct.</param> public static void ReconstructClusterMsMs(this UMCClusterLight cluster, SpectraProviderCache providers, bool getPeaks = true) { foreach (var feature in cluster.Features) { var provider = providers.GetSpectraProvider(feature.GroupId); feature.ReconstructUMCMsMs(provider, getPeaks); } }
private UMCClusterLight CreateCluster(double mass, double net, double drift) { var cluster = new UMCClusterLight(); cluster.MassMonoisotopic = mass; cluster.Net = net; cluster.Net = net; cluster.DriftTime = drift; return(cluster); }
public void TestDistanceChangeEuclidean() { var cluster = new UMCClusterLight(); cluster.MassMonoisotopic = 500; cluster.Net = .5; cluster.Net = .5; cluster.DriftTime = 20; var euclid = new EuclideanDistanceMetric <UMCClusterLight>(); DistanceFunction <UMCClusterLight> func = euclid.EuclideanDistance; var deltaNet = .01; double deltaMassPPM = 1; double deltaDriftTime = 1; Console.WriteLine("Mass Diff, Mass Dist, Net, Net Dist, Drift, Drift Dist"); for (var i = 0; i < 50; i++) { var clusterD = new UMCClusterLight(); var clusterN = new UMCClusterLight(); var clusterM = new UMCClusterLight(); clusterM.DriftTime = cluster.DriftTime + deltaDriftTime; clusterM.Net = cluster.Net + deltaNet; clusterM.Net = cluster.Net + deltaNet; clusterM.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM * i); clusterN.DriftTime = cluster.DriftTime + deltaDriftTime; clusterN.Net = cluster.Net + (deltaNet * i); clusterN.Net = cluster.Net + (deltaNet * i); clusterN.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM); clusterD.DriftTime = cluster.DriftTime + (deltaDriftTime * i); clusterD.Net = cluster.Net + deltaNet; clusterD.Net = cluster.Net + deltaNet; clusterD.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM); var distM = func(cluster, clusterM); var distN = func(cluster, clusterN); var distD = func(cluster, clusterD); var output = string.Format("{0},{1},{2},{3},{4},{5}", deltaMassPPM * i, distM, deltaNet * i, distN, deltaDriftTime * i, distD); Console.WriteLine(output); } }
public ClusterPoint(UMCClusterLight umcClusterLight) { this.UMCClusterLight = umcClusterLight; this.Rectangle = new RectangleF { X = (float)umcClusterLight.Net, Y = (float)umcClusterLight.MassMonoisotopicAligned, Width = 0.00001f, Height = 0.01f }; }
/// <summary> /// Determines if MS/MS should also be discovered. /// </summary> /// <param name="cluster"></param> /// <param name="providers"></param> /// <param name="getMsMS"></param> public static void ReconstructUMCCluster(this UMCClusterLight cluster, FeatureDataAccessProviders providers, bool getUmcs, bool getMatches, bool getMsFeature, bool getMsMs) { if (getUmcs) { // Reconstruct UMCs cluster.Features.Clear(); var features = providers.FeatureCache.FindByClusterID(cluster.Id); if (features == null || features.Count == 0) { return; } var totalSpectra = 0; var totalIdentified = 0; foreach (var feature in features) { cluster.AddChildFeature(feature); if (getMsFeature) { feature.ReconstructUMC(providers, getMsMs); foreach (var msFeature in feature.MsFeatures) { totalSpectra += msFeature.MSnSpectra.Count; foreach (var spectrum in msFeature.MSnSpectra) { if (spectrum.Peptides.Count > 0) { totalIdentified++; } } } } } cluster.IdentifiedSpectraCount = totalIdentified; cluster.MsMsCount = totalSpectra; } if (getMatches) { // Reconstruct matches cluster.MassTags.Clear(); var matches = providers.MassTagMatches.FindByClusterId(cluster.Id); if (matches != null && matches.Any()) { var massTags = providers.MassTags.FindMassTags(matches.Select(match => match.MassTagId).ToList()); cluster.MassTags.AddRange(massTags); } } }
public static bool HasMsMs(this UMCClusterLight cluster) { foreach (var feature in cluster.Features) { var hasMsMs = feature.HasMsMs(); if (hasMsMs) { return(true); } } return(false); }
/// <summary> /// Retrieves a list of known peptides attributed to this cluster. /// </summary> /// <param name="cluster"></param> /// <param name="providers"></param> /// <returns></returns> public static List <MSSpectra> FindSpectra(this UMCClusterLight cluster) { var peptides = new List <MSSpectra>(); foreach (var feature in cluster.Features) { foreach (var msFeature in feature.MsFeatures) { peptides.AddRange(msFeature.MSnSpectra); } } return(peptides); }
/// <summary> /// Retrieves a list of known peptides attributed to this cluster. /// </summary> /// <param name="cluster"></param> /// <param name="providers"></param> /// <returns></returns> public static List <MSSpectra> GetLoadedSpectra(this UMCClusterLight cluster) { var spectra = new List <MSSpectra>(); foreach (var feature in cluster.Features) { foreach (var msFeature in feature.MsFeatures) { spectra.AddRange(msFeature.MSnSpectra); } } return(spectra); }
/// <summary> /// Reads the clusters and filters cluster by cluster. /// </summary> private static List <UMCClusterLight> ReadClusters(string path, FilteringOptions options) { var clusters = new List <UMCClusterLight>(); var totalClusters = 0; using (TextReader reader = File.OpenText(path)) { reader.ReadLine(); string line; while ((line = reader.ReadLine()) != null) { if (string.IsNullOrWhiteSpace(line)) { continue; } var data = line.Split(','); var mass = Convert.ToDouble(data[CONST_COLUMN_MASS]); var retentionTime = Convert.ToDouble(data[CONST_COLUMN_NET]); var cluster = new UMCClusterLight { Id = Convert.ToInt32(data[CONST_COLUMN_ID]), MassMonoisotopic = mass, MassMonoisotopicAligned = mass, NetAligned = retentionTime, Net = retentionTime, DriftTime = Convert.ToDouble(data[CONST_COLUMN_DRIFT]), Tightness = Convert.ToDouble(data[CONST_COLUMN_TIGHTNESS]), AmbiguityScore = Convert.ToDouble(data[CONST_COLUMN_AMBIGUITY]), DatasetMemberCount = Convert.ToInt32(data[CONST_COLUMN_DATASET_MEMBERS]), MemberCount = Convert.ToInt32(data[CONST_COLUMN_TOTAL_MEMBERS]) }; var shouldFilter = ShouldFilterCluster(cluster, options); if (!shouldFilter) { clusters.Add(cluster); } totalClusters++; } } Logger.PrintMessage(string.Format("Found {0} filtered clusters from {1} total clusters", clusters.Count, totalClusters)); return(clusters); }
public void TestLamarcheGridApp(string csvPath) { //Read a csv file, put the data into a new UMCLight for each one var csvFileText = File.ReadAllLines(csvPath); var csvDataList = new List <UMCLight> { Capacity = csvFileText.Length }; foreach (var line in csvFileText) { var parsedLine = line.Split(','); var umcDataMember = new UMCLight(); //put the data from the parsed line into the umcDataMember in the appropriate fashion csvDataList.Add(umcDataMember); } //Create clusters from the data read in from the file UMCClusterLight cluster = null; var filteredClusters = new List <UMCClusterLight>(); if (!Filter(cluster)) { //Save the cluster filteredClusters.Add(cluster); } //Read a mtdb file using MACore or sqliteDb var databasePath = @"C:\UnitTestFolder\MSGFPlus\blah.db"; //Either read from console, or entered at program execution // Console.ReadLine(databasePath) or databasePath = args[2] var database = ReadDatabase(databasePath); var stacAdapter = new STACAdapter <UMCClusterLight>(); var matchList = stacAdapter.PerformPeakMatching(filteredClusters, database); string writePath = null; // As with databasePath, could either be read from console, or entered at program execution // Console.ReadLine(writePath) or, if(args.Length >= 4){ writePath = args[3]; } // If writePath isn't entered, then it writes to a default file, defined inside the WriteData method WriteData(matchList, writePath); }
/// <summary> /// Retrieves a list of known peptides attributed to this cluster. /// </summary> /// <param name="cluster"></param> /// <param name="providers"></param> /// <returns></returns> public static List <Peptide> FindPeptides(this UMCClusterLight cluster) { var peptides = new List <Peptide>(); foreach (var feature in cluster.Features) { foreach (var msFeature in feature.MsFeatures) { foreach (var spectrum in msFeature.MSnSpectra) { peptides.AddRange(spectrum.Peptides); } } } return(peptides); }
public void TestAddClusters(string name) { var databasePath = Path.Combine(m_basePath, name); // This is a factory based method that creates a set of data access providers used throughout MultiAlign var providers = DataAccessFactory.CreateDataAccessProviders(databasePath, true); var clusters = new List<UMCClusterLight>(); for (var i = 0; i < 10; i++) { var cluster = new UMCClusterLight(); cluster.Id = i; cluster.GroupId = 0; } providers.ClusterCache.AddAll(clusters); }
public void TestAddClusters(string name) { var databasePath = Path.Combine(m_basePath, name); // This is a factory based method that creates a set of data access providers used throughout MultiAlign var providers = DataAccessFactory.CreateDataAccessProviders(databasePath, true); var clusters = new List <UMCClusterLight>(); for (var i = 0; i < 10; i++) { var cluster = new UMCClusterLight(); cluster.Id = i; cluster.GroupId = 0; } providers.ClusterCache.AddAll(clusters); }
public void TestTwoClusters(string path) { Console.WriteLine("Test: " + path); var features = GetClusterData(Path.Combine(TestPathSingleton.TestDirectory, path)); Assert.IsNotEmpty(features); var cluster = new UMCClusterLight(); cluster.Id = features[0].Id; features.ForEach(x => cluster.AddChildFeature(x)); cluster.CalculateStatistics(ClusterCentroidRepresentation.Median); Console.WriteLine("Cluster\tMass\tNET"); Console.WriteLine("{0}\t{1}\t{2}\t", cluster.Id, cluster.MassStandardDeviation, cluster.NetStandardDeviation); Console.WriteLine(); var distance = new EuclideanDistanceMetric <FeatureLight>(); features.ForEach(x => Console.WriteLine(distance.EuclideanDistance(x, cluster))); }
public static Dictionary <int, int> BuildChargeStateHistogram(this UMCClusterLight cluster) { var chargeHistogram = new Dictionary <int, int>(); for (var i = 1; i < 10; i++) { chargeHistogram.Add(i, 0); } foreach (var feature in cluster.Features) { var chargeMap = feature.CreateChargeMap(); foreach (var charge in chargeMap.Keys) { if (!chargeHistogram.ContainsKey(charge)) { chargeHistogram.Add(charge, 0); } chargeHistogram[charge] = chargeHistogram[charge] + 1; } } return(chargeHistogram); }
/// <summary> /// Event handler for OxyPlot left mouse click. /// </summary> /// <param name="sender">The sending PlotView.</param> /// <param name="args">The event arguments.</param> private void ClusterPlotMouseDown(object sender, OxyMouseDownEventArgs args) { if (args.ChangedButton != OxyMouseButton.Left) { return; } var series = this.ClusterPlotModel.GetSeriesFromPoint(args.Position, 10); if (series != null) { var result = series.GetNearestPoint(args.Position, false); if (result != null) { var clusterPoint = result.Item as ClusterPoint; if (clusterPoint != null) { this.SelectedCluster = clusterPoint.UMCClusterLight; } } } }
private static bool ShouldFilterCluster(UMCClusterLight cluster, FilteringOptions options) { // // Total dataset member count ~ // Ratio of members dataset : total // 1 but not > 1.5-2 // var datasetMemberCount = cluster.DatasetMemberCount; if (datasetMemberCount < options.TotalDatasetMembers) { return(true); } var totalMembers = cluster.MemberCount; var ratio = Convert.ToDouble(totalMembers) / Convert.ToDouble(datasetMemberCount); if (ratio <= options.MaxRatio && ratio >= options.MinRatio) { return(false); } return(true); }
//[TestCase(@"ClusterData\clusterData-merged-nodelin.txt")] public void TestWeightedAverageLinkage(string path) { Console.WriteLine("Test: " + path); var features = GetClusterData(Path.Combine(TestPaths.TestFilesDirectory, path)); Assert.IsNotEmpty(features); var cluster = new UMCClusterLight(); cluster.Id = features[0].Id; features.ForEach(x => cluster.AddChildFeature(x)); var maps = new Dictionary <int, UMCClusterLight>(); var average = new UMCAverageLinkageClusterer <UMCLight, UMCClusterLight>(); average.Parameters = new FeatureClusterParameters <UMCLight>(); average.Parameters.CentroidRepresentation = ClusterCentroidRepresentation.Mean; average.Parameters.Tolerances = new Algorithms.FeatureTolerances(); var distance = new WeightedEuclideanDistance <UMCLight>(); average.Parameters.DistanceFunction = distance.EuclideanDistance; var clusters = average.Cluster(features); Console.WriteLine("dataset\tfeature\tmass\tnet\tdrift"); foreach (var newCluster in clusters) { foreach (var feature in newCluster.Features) { Console.WriteLine("{0},{1},{2},{3},{4}", feature.GroupId, feature.Id, feature.Net, feature.MassMonoisotopicAligned, feature.DriftTime); } } }
public void TestReprocessing(string path) { Console.WriteLine("Test: " + path); var features = GetClusterData(Path.Combine(TestPathSingleton.TestDirectory, path)); Assert.IsNotEmpty(features); var cluster = new UMCClusterLight(); cluster.Id = features[0].Id; features.ForEach(x => cluster.AddChildFeature(x)); cluster.CalculateStatistics(ClusterCentroidRepresentation.Median); Console.WriteLine("Cluster\tMass\tNET"); Console.WriteLine("{0}\t{1}\t{2}\t", cluster.Id, cluster.MassStandardDeviation, cluster.NetStandardDeviation); Console.WriteLine(); IClusterReprocessor <UMCLight, UMCClusterLight> reprocessor = new MedianSplitReprocessor <UMCLight, UMCClusterLight>(); reprocessor.ProcessClusters(new List <UMCClusterLight> { cluster }); }
public List<UMCClusterLight> CreateSingletonClustersFromClusteredFeatures(List<UMCClusterLight> clusters) { var newClusters = new List<UMCClusterLight>(); var i = 0; foreach (var cluster in clusters) { foreach (var feature in cluster.Features) { var x = new UMCClusterLight { MassMonoisotopic = feature.MassMonoisotopic, Net = feature.Net }; x.Net = feature.NetAligned; x.DriftTime = feature.DriftTime; x.ChargeState = feature.ChargeState; x.Id = i++; x.AddChildFeature(feature); newClusters.Add(x); } } return newClusters; }
public UMCCollectionTreeViewModel(UMCClusterLight parentCluster, TreeItemViewModel parent) { m_parent = parent; m_parentCluster = parentCluster; m_features = new ObservableCollection<UMCTreeViewModel>(); }
private static bool ShouldFilterCluster(UMCClusterLight cluster, FilteringOptions options) { // // Total dataset member count ~ // Ratio of members dataset : total // 1 but not > 1.5-2 // var datasetMemberCount = cluster.DatasetMemberCount; if (datasetMemberCount < options.TotalDatasetMembers) return true; var totalMembers = cluster.MemberCount; var ratio = Convert.ToDouble(totalMembers)/Convert.ToDouble(datasetMemberCount); if (ratio <= options.MaxRatio && ratio >= options.MinRatio) return false; return true; }
public static void ExportMsMs(this UMCClusterLight cluster, string path, List <DatasetInformation> datasets, IMsMsSpectraWriter writer) { // Let's map the datasets first. var readers = new Dictionary <int, ISpectraProvider>(); var information = new Dictionary <int, DatasetInformation>(); datasets.ForEach(x => information.Add(x.DatasetId, x)); // We are only loading what datasets we have to here! // The point is, each cluster or feature may have come from a different raw data source... // since we dont store all of the data in memory, we have to fetch it from the appropriate source. // This means that we have to go into the raw data and get the scans for an MSMS spectra. foreach (var feature in cluster.Features) { if (!readers.ContainsKey(feature.GroupId)) { if (information.ContainsKey(feature.GroupId)) { var singleInfo = information[feature.GroupId]; if (singleInfo.RawFile != null) { // Make sure that we have a file. if (!File.Exists(singleInfo.RawFile.Path)) { continue; } // Here we create a data file reader for the file we want to access. var provider = RawLoaderFactory.CreateFileReader(singleInfo.RawFile.Path); // Then we make sure we key it to the provider. provider.AddDataFile(singleInfo.RawFile.Path, feature.GroupId); // Then make sure we map it for a dataset, so when we sort through a cluster // we make sure that we can access in O(1) time. readers.Add(feature.GroupId, provider); } } } } // We flag the first write, so that if the file exists, we overwrite. They should have done // checking to make sure that the file was already created...we dont care. var firstWrite = true; foreach (var feature in cluster.Features) { if (readers.ContainsKey(feature.GroupId)) { var provider = readers[feature.GroupId]; foreach (var msFeature in feature.MsFeatures) { foreach (var spectrum in msFeature.MSnSpectra) { var summary = new ScanSummary(); var data = provider.GetRawSpectra(spectrum.Scan, spectrum.GroupId, out summary); spectrum.Peaks = data; spectrum.ScanMetaData = summary; } if (firstWrite) { writer.Write(path, msFeature.MSnSpectra); } else { writer.Append(path, msFeature.MSnSpectra); } } } } }
public PeptideCollectionTreeViewModel(UMCClusterLight parentCluster) : this(parentCluster, null) { }
/// <summary> /// Gets a cluster and it's subsequent data structures. /// </summary> /// <param name="cluster"></param> /// <param name="providers"></param> public static void ReconstructUMCCluster(this UMCClusterLight cluster, FeatureDataAccessProviders providers) { cluster.ReconstructUMCCluster(providers, true, true, true, true); }
public PeptideCollectionTreeViewModel(UMCClusterLight parentCluster, TreeItemViewModel parent) { m_parent = parent; m_parentCluster = parentCluster; }
public void TestDistanceChangeEuclidean() { var cluster = new UMCClusterLight(); cluster.MassMonoisotopic = 500; cluster.Net = .5; cluster.Net = .5; cluster.DriftTime = 20; var euclid = new EuclideanDistanceMetric<UMCClusterLight>(); DistanceFunction<UMCClusterLight> func = euclid.EuclideanDistance; var deltaNet = .01; double deltaMassPPM = 1; double deltaDriftTime = 1; Console.WriteLine("Mass Diff, Mass Dist, Net, Net Dist, Drift, Drift Dist"); for (var i = 0; i < 50; i++) { var clusterD = new UMCClusterLight(); var clusterN = new UMCClusterLight(); var clusterM = new UMCClusterLight(); clusterM.DriftTime = cluster.DriftTime + deltaDriftTime; clusterM.Net = cluster.Net + deltaNet; clusterM.Net = cluster.Net + deltaNet; clusterM.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM*i); clusterN.DriftTime = cluster.DriftTime + deltaDriftTime; clusterN.Net = cluster.Net + (deltaNet*i); clusterN.Net = cluster.Net + (deltaNet*i); clusterN.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM); clusterD.DriftTime = cluster.DriftTime + (deltaDriftTime*i); clusterD.Net = cluster.Net + deltaNet; clusterD.Net = cluster.Net + deltaNet; clusterD.MassMonoisotopic = FeatureLight.ComputeDaDifferenceFromPPM(cluster.MassMonoisotopic, deltaMassPPM); var distM = func(cluster, clusterM); var distN = func(cluster, clusterN); var distD = func(cluster, clusterD); var output = string.Format("{0},{1},{2},{3},{4},{5}", deltaMassPPM*i, distM, deltaNet*i, distN, deltaDriftTime*i, distD); Console.WriteLine(output); } }
public void TestClusterGeneration(string databasePath, string crossPath, int charge, int minimumClusterSize) { File.Delete(databasePath); NHibernateUtil.ConnectToDatabase(databasePath, true); IDatasetDAO datasetCache = new DatasetDAOHibernate(); IUmcClusterDAO clusterCache = new UmcClusterDAOHibernate(); IUmcDAO featureCache = new UmcDAOHibernate(); // Creating a dataset Console.WriteLine("Creating dummy datasets"); var datasets = new List<DatasetInformation>(); var total = 10; for (var i = 0; i < total; i++) { var dataset = new DatasetInformation(); dataset.DatasetId = i; dataset.DatasetName = "test" + i; datasets.Add(dataset); } datasetCache.AddAll(datasets); datasets.Clear(); datasets = datasetCache.FindAll(); // Create features Console.WriteLine("Creating features"); var features = new List<UMCLight>(); var clusters = new List<UMCClusterLight>(); var x = new Random(); var featureId = 0; for (var i = 0; i < 100; i++) { var cluster = new UMCClusterLight(); cluster.Id = i; cluster.AmbiguityScore = i; cluster.Tightness = i; var N = x.Next(1, total); cluster.Id = i; cluster.ChargeState = charge; var hash = new HashSet<int>(); for (var j = 0; j < N; j++) { var did = -1; do { did = x.Next(0, total); if (!hash.Contains(did)) { hash.Add(did); break; } } while (true); var feature = new UMCLight(); feature.GroupId = did; feature.Id = featureId++; feature.ChargeState = charge; feature.MassMonoisotopic = x.NextDouble(); feature.Net = x.NextDouble(); feature.AbundanceSum = x.Next(100, 200); feature.Abundance = feature.Abundance; feature.ClusterId = cluster.Id; cluster.AddChildFeature(feature); features.Add(feature); } cluster.CalculateStatistics(ClusterCentroidRepresentation.Mean); clusters.Add(cluster); } featureCache.AddAll(features); clusterCache.AddAll(clusters); clusters = clusterCache.FindAll(); Console.WriteLine("Find all clusters"); clusters = clusterCache.FindByCharge(charge); WriteClusters(datasets, clusters, minimumClusterSize, charge, crossPath, databasePath, 300000); }
public List<UMCClusterLight> ReadClusters(string path) { var clusters = new List<UMCClusterLight>(); var data = File.ReadLines(path).ToList(); var isClusters = true; var i = 1; var clusterMap = new Dictionary<int, UMCClusterLight>(); while (i < data.Count && isClusters) { isClusters = !(data[i].ToLower().Contains("dataset")); if (isClusters) { var cluster = new UMCClusterLight(); var lineData = data[i].Split(','); cluster.Id = Convert.ToInt32(lineData[0]); cluster.MassMonoisotopic = Convert.ToDouble(lineData[1]); cluster.Net = Convert.ToDouble(lineData[2]); cluster.Net = Convert.ToDouble(lineData[2]); cluster.DriftTime = Convert.ToDouble(lineData[3]); cluster.ChargeState = Convert.ToInt32(lineData[4]); if (!clusterMap.ContainsKey(cluster.Id)) { clusterMap.Add(cluster.Id, cluster); } clusters.Add(cluster); } i = i + 1; } i = i + 1; while (i < data.Count) { var line = data[i]; var lineData = line.Split(','); if (line.Length > 6) { var clusterID = Convert.ToInt32(lineData[0]); var feature = new UMCLight { GroupId = Convert.ToInt32(lineData[1]), Id = Convert.ToInt32(lineData[2]), MassMonoisotopic = Convert.ToDouble(lineData[3]), Net = Convert.ToDouble(lineData[4]), NetAligned = Convert.ToDouble(lineData[4]), DriftTime = Convert.ToDouble(lineData[5]), ChargeState = Convert.ToInt32(lineData[6]) }; if (clusterMap.ContainsKey(clusterID)) { clusterMap[clusterID].AddChildFeature(feature); } } i = i + 1; } return clusters; }
public UmcClusterChargeHistogram(UMCClusterLight cluster, string name) : base(cluster.BuildChargeStateHistogram(), name) { m_xAxis.Maximum = 10; }
public MsMsCollectionTreeViewModel(UMCClusterLight cluster) : this(cluster, null) { }
public MsMsCollectionTreeViewModel(UMCClusterLight cluster, UMCClusterTreeViewModel parent) { m_cluster = cluster; m_parent = parent; m_spectra = new ObservableCollection<MsMsTreeViewModel>(); }
/// <summary> /// Reads the clusters and filters cluster by cluster. /// </summary> private static List<UMCClusterLight> ReadClusters(string path, FilteringOptions options) { var clusters = new List<UMCClusterLight>(); var totalClusters = 0; using (TextReader reader = File.OpenText(path)) { reader.ReadLine(); string line; while ((line = reader.ReadLine()) != null) { var data = line.Split(','); var mass = Convert.ToDouble(data[CONST_COLUMN_MASS]); var retentionTime = Convert.ToDouble(data[CONST_COLUMN_NET]); var cluster = new UMCClusterLight { Id = Convert.ToInt32(data[CONST_COLUMN_ID]), MassMonoisotopic = mass, MassMonoisotopicAligned = mass, NetAligned = retentionTime, Net = retentionTime, DriftTime = Convert.ToDouble(data[CONST_COLUMN_DRIFT]), Tightness = Convert.ToDouble(data[CONST_COLUMN_TIGHTNESS]), AmbiguityScore = Convert.ToDouble(data[CONST_COLUMN_AMBIGUITY]), DatasetMemberCount = Convert.ToInt32(data[CONST_COLUMN_DATASET_MEMBERS]), MemberCount = Convert.ToInt32(data[CONST_COLUMN_TOTAL_MEMBERS]) }; var shouldFilter = ShouldFilterCluster(cluster, options); if (!shouldFilter) clusters.Add(cluster); totalClusters++; } } Logger.PrintMessage(string.Format("Found {0} filtered clusters from {1} total clusters", clusters.Count, totalClusters)); return clusters; }
// might be different cluster object private static bool Filter(UMCClusterLight cluster) { //Perform filtering as necesary, returns true if the cluster does not pass the filter return true; }