private IEnumerable <XicFeature> CreateXicTargetsYield(IEnumerable <UMCLight> features, double massError)
{
int id = 0;
foreach (var feature in features)
{
int minScan = Int32.MaxValue;
int maxScan = 0;
foreach (var msFeature in feature.MsFeatures)
{
minScan = Math.Min(minScan, msFeature.Scan);
maxScan = Math.Max(maxScan, msFeature.Scan);
}
yield return(new XicFeature
{
HighMz = FeatureLight.ComputeDaDifferenceFromPPM(feature.Mz, -massError),
LowMz = FeatureLight.ComputeDaDifferenceFromPPM(feature.Mz, massError),
Mz = feature.Mz,
Feature = feature,
Id = id++,
EndScan = minScan + ScanWindowSize,
StartScan = maxScan - ScanWindowSize,
ChargeState = feature.ChargeState
});
}
}
public void MassMassCalculations(double massX, double massY)
{
var ppm = FeatureLight.ComputeMassPPMDifference(massX, massY);
var massYdelta = FeatureLight.ComputeDaDifferenceFromPPM(massX, ppm);
Assert.AreEqual(massY, massYdelta);
}
public void MassPPMCalculations(double massX, double ppm, double epsilon)
{
var massYdelta = FeatureLight.ComputeDaDifferenceFromPPM(massX, ppm);
var ppmDelta = FeatureLight.ComputeMassPPMDifference(massX, massYdelta);
//Assert.IsTrue( (ppm - ppmDelta) < epsilon);
Assert.Less(ppm - ppmDelta, epsilon);
}
/// <summary>
/// Creates XIC Targets from a list of UMC Features
/// </summary>
/// <param name="features"></param>
/// <param name="massError"></param>
/// <returns></returns>
private List <XicFeature> CreateXicTargets(IEnumerable <UMCLight> features, double massError)
{
var allFeatures = new List <XicFeature>();
// Create XIC Features
var id = 0;
// Then for each feature turn it into a new feature
foreach (var feature in features)
{
// Build XIC features from each
var x = feature.CreateChargeMap();
foreach (var charge in x.Keys)
{
double maxIntensity = 0;
double mz = 0;
var min = double.MaxValue;
var max = double.MinValue;
var scanStart = int.MaxValue;
var scanEnd = 0;
foreach (var chargeFeature in x[charge])
{
min = Math.Min(min, chargeFeature.Mz);
max = Math.Max(max, chargeFeature.Mz);
scanStart = Math.Min(scanStart, chargeFeature.Scan);
scanEnd = Math.Min(scanStart, chargeFeature.Scan);
if (chargeFeature.Abundance > maxIntensity)
{
maxIntensity = chargeFeature.Abundance;
mz = chargeFeature.Mz;
}
}
// Clear the ms feature list...because later we will populate it
feature.MsFeatures.Clear();
var xicFeature = new XicFeature
{
HighMz = FeatureLight.ComputeDaDifferenceFromPPM(mz, -massError),
LowMz = FeatureLight.ComputeDaDifferenceFromPPM(mz, massError),
Mz = mz,
Feature = feature,
Id = id++,
EndScan = scanEnd + ScanWindowSize,
StartScan = scanStart - ScanWindowSize,
ChargeState = charge
};
allFeatures.Add(xicFeature);
}
}
return(allFeatures);
}
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 TestDistances()
{
var dist = new WeightedEuclideanDistance <UMCClusterLight>();
var clusterA = CreateCluster(500, .2, 27);
var clusterB = CreateCluster(500, .2, 27);
var N = 50;
var stepMass = .5;
var stepNET = .001;
var stepDrift = .01;
Console.WriteLine("Walk in drift time");
for (var i = 0; i < N; i++)
{
clusterB.DriftTime += stepDrift;
var distance = dist.EuclideanDistance(clusterA, clusterB);
Console.WriteLine("{0}, {1}, {3}, {2}", clusterB.DriftTime, clusterB.DriftTime, distance, clusterB.DriftTime - clusterA.DriftTime);
}
Console.WriteLine();
Console.WriteLine("Walk in net ");
clusterB.DriftTime = 27;
for (var i = 0; i < N; i++)
{
clusterB.Net += stepNET;
var distance = dist.EuclideanDistance(clusterA, clusterB);
Console.WriteLine("{0}, {1}, {3}, {2}", clusterB.Net, clusterB.Net, distance, clusterB.Net - clusterA.Net);
}
Console.WriteLine();
Console.WriteLine("Walk in mass ");
clusterB.Net = .2;
for (var i = 0; i < N; i++)
{
var d = FeatureLight.ComputeDaDifferenceFromPPM(clusterA.MassMonoisotopic, stepMass * i);
clusterB.MassMonoisotopic = d;
var distance = dist.EuclideanDistance(clusterA, clusterB);
Console.WriteLine("{0}, {1}, {3}, {2}", clusterB.MassMonoisotopic,
clusterB.MassMonoisotopic,
distance,
FeatureLight.ComputeMassPPMDifference(clusterA.MassMonoisotopic, clusterB.MassMonoisotopic));
}
}
/// <summary>
/// Creates an XIC from the m/z values provided.
/// </summary>
/// <param name="mz"></param>
/// <param name="massError"></param>
/// <param name="minScan"></param>
/// <param name="maxScan"></param>
/// <param name="provider"></param>
/// <returns></returns>
public IEnumerable <MSFeatureLight> CreateXic(double mz,
double massError,
int minScan,
int maxScan,
ISpectraProvider provider)
{
var newFeatures = new List <MSFeatureLight>();
var lower = FeatureLight.ComputeDaDifferenceFromPPM(mz, massError);
var higher = FeatureLight.ComputeDaDifferenceFromPPM(mz, -massError);
for (var i = minScan; i < maxScan; i++)
{
List <XYData> spectrum = null;
try
{
var summary = new ScanSummary();
spectrum = provider.GetRawSpectra(i, 0, 1, out summary);
}
catch
{
}
if (spectrum == null)
{
continue;
}
var data = (from x in spectrum
where x.X > lower && x.X < higher
select x).ToList();
var summedIntensity = data.Sum(x => x.Y);
var newFeature = new MSFeatureLight
{
Scan = i,
Net = i,
Abundance = Convert.ToInt64(summedIntensity)
};
newFeatures.Add(newFeature);
}
return(newFeatures);
}
public void TestCreateDummyDatabase(string databasePath, int totalDatasets, int totalClusters)
{
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 = totalDatasets;
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 < totalClusters; i++)
{
var N = x.Next(1, total);
var charge = x.Next(1, 10);
var hash = new HashSet <int>();
var net = x.NextDouble();
var mass = 400 + (1600 * x.NextDouble());
var dt = 60 * x.NextDouble();
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 = FeatureLight.ComputeDaDifferenceFromPPM(mass, 3);
feature.MassMonoisotopicAligned = feature.MassMonoisotopic;
feature.Net = net + .03 * x.NextDouble();
feature.NetAligned = feature.Net;
feature.Net = feature.Net;
feature.DriftTime = dt;
feature.AbundanceSum = x.Next(100, 200);
feature.Abundance = feature.Abundance;
feature.ClusterId = -1;
features.Add(feature);
}
}
featureCache.AddAll(features);
}
