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;
}
