/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="basisFunction">Basis function</param>
/// <param name="coeffs">initial Coefficients</param>
/// <returns></returns>
protected SolverReport EvaluateFunction(List <double> x, List <double> y, BasisFunctionBase basisFunction, ref double[] coeffs)
{
coeffs = basisFunction.Coefficients;
basisFunction.Scale(x);
alglib.ndimensional_pfunc myDelegate = basisFunction.FunctionDelegate;
var solver = new LevenburgMarquadtSolver();
solver.BasisFunction = myDelegate;
var worked = solver.Solve(x, y, ref coeffs);
//for (int i = 0; i < x.Count; i++)
//{
// // This is what we are fitting
// double xValue = x[i];
// // This is what it should fit to
// double yValue = y[i];
// // This is the warped guy
// double fitValue = 0;
// //quadSolver2.FunctionDelegate(coeffs, new double[] { xValue }, ref fitValue, null);
// myDelegate.Invoke(coeffs, new double[] { xValue }, ref fitValue, null);
//}
//Console.WriteLine(Environment.NewLine);
return(worked);
}
public void FitChromatograms(Chromatogram profile,
BasisFunctionBase basisFunction)
{
var solver = new LevenburgMarquadtSolver();
solver.BasisFunction = basisFunction.FunctionDelegate;
var coeffs = basisFunction.Coefficients;
solver.Solve(profile.Points, ref coeffs);
var minScan = profile.Points.Min(x => x.X);
var maxScan = profile.Points.Max(x => x.X);
var scanRange = Math.Abs(maxScan - minScan);
var deltaScan = scanRange / (scanRange * 4);
var scan = minScan;
var fitPoints = new List <XYData>();
while (scan <= maxScan)
{
var y = basisFunction.Evaluate(coeffs, scan);
fitPoints.Add(new XYData(scan, y));
scan += deltaScan;
}
profile.FitCoefficients = coeffs;
profile.FitPoints = fitPoints;
}
/// <summary>
/// Scores two chromatograms using their basis functions.
/// </summary>
/// <param name="profileA">chromatogram A</param>
/// <param name="profileB">chromatogram B</param>
/// <param name="basisFunction">Function used to interpolate</param>
/// <param name="intensityProfile"></param>
/// <returns>R-squared value for a given linear regression between intensity matrix</returns>
public double ScoreChromatogramIntensity(Chromatogram profileA,
Chromatogram profileB,
BasisFunctionBase basisFunction,
ref List <XYData> intensityProfile)
{
if (intensityProfile == null)
{
throw new ArgumentNullException("intensityProfile");
}
var minScan = profileA.FitPoints.Min(x => x.X);
var maxScan = profileA.FitPoints.Max(x => x.X);
minScan = Math.Min(minScan, profileB.FitPoints.Min(x => x.X));
maxScan = Math.Max(maxScan, profileB.FitPoints.Max(x => x.X));
var deltaScan = Math.Abs(maxScan - minScan) / 100;
var scan = minScan;
var pairs = new List <XYData>();
while (scan <= maxScan)
{
var x = basisFunction.Evaluate(profileA.FitCoefficients, scan);
var y = basisFunction.Evaluate(profileB.FitCoefficients, scan);
pairs.Add(new XYData(x, y));
scan += deltaScan;
}
var linearRegression = BasisFunctionFactory.BasisFunctionSelector(BasisFunctionsEnum.Linear);
var solver = new LevenburgMarquadtSolver {
BasisFunction = linearRegression.FunctionDelegate
};
var coeffs = linearRegression.Coefficients;
var report = solver.Solve(pairs, ref coeffs);
return(report.RSquared);
}
public void SolveAsymmetricGaussianFactory(string path, BasisFunctionsEnum functionChoise)
{
var data = ReadXicDatabase(Path.Combine(TestPathSingleton.TestDirectory, path));
var newData = new List <Xic>();
foreach (var xic in data)
{
var basisFunction = BasisFunctionFactory.BasisFunctionSelector(functionChoise);
var coefficients = basisFunction.Coefficients;
var start = xic.x.Min() - .5;
var stop = xic.x.Max() + .5;
var A = xic.y.Max();
A += (A * .05);
var width = Math.Abs(stop - start);
coefficients[0] = start + ((stop - start) / 2);
coefficients[1] = A;
coefficients[2] = width * .5;
coefficients[3] = coefficients[2];
//Console.WriteLine("Xic {0}", xic.id);
//Console.WriteLine();
for (var i = 0; i < xic.x.Count; i++)
{
// Console.WriteLine("{0}\t{1}", xic.x[i], xic.y[i]);
}
SolverReport worked = null;
Console.WriteLine();
var showDetails = false;
try
{
worked = EvaluateFunction(xic.x, xic.y, basisFunction, ref coefficients, showDetails);
}
catch (Exception)
{
continue;
}
// First solve for the function
var solver = new LevenburgMarquadtSolver();
var numberOfSamples = 100;
// Calculate the width an spacing of each of the trapezoids.
var delta = width / Convert.ToDouble(numberOfSamples);
var x = start;
var newXic = new Xic();
newXic.x = new List <double>();
newXic.y = new List <double>();
newXic.charge = xic.charge;
newXic.scoreName = xic.scoreName;
newXic.score = xic.score;
newXic.id = xic.id;
newXic.prevXic = xic;
newXic.report = worked;
newXic.reviewer = xic.reviewer;
// We already evaluated the first point, now for each element within
for (var i = 0; i < numberOfSamples + 1; i++)
{
x += delta;
var y = basisFunction.Evaluate(coefficients, x);
newXic.x.Add(x);
newXic.y.Add(y);
// Console.WriteLine("{0}\t{1}", x, y);
}
//Console.WriteLine();
newData.Add(newXic);
}
var newPath = path.Replace(".xic", functionChoise + "_fit.xic");
using (TextWriter writer = File.CreateText(newPath))
{
foreach (var feature in newData)
{
writer.WriteLine("id\t{0}\tcharge\t{1}", feature.id, feature.charge);
writer.WriteLine("score\t{0}\tscoreName\t{1}", feature.score, feature.scoreName);
writer.WriteLine("reviewer\t{0}", feature.reviewer);
writer.WriteLine("R2\t{0}", feature.report.RSquared);
writer.WriteLine("Rms\t{0}", feature.report.RmsError);
writer.WriteLine("Converged\t{0}", feature.report.DidConverge);
writer.WriteLine("mz\ttime\tintensity");
var prev = feature.prevXic;
for (var i = 0; i < feature.x.Count; i++)
{
var prevTime = "";
var prevInt = "";
if (prev != null && i < prev.x.Count)
{
prevTime = prev.x[i].ToString();
prevInt = prev.y[i].ToString();
}
writer.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}", feature.mz, feature.x[i], feature.y[i], prevTime, prevInt);
}
writer.WriteLine();
}
}
}
/// <summary>
/// Scores a feature and adjusts its abundance accordingly.
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public void ScoreFeature(UMCLight feature)
{
// Get the basis function of interest
var basisFunction = BasisFunctionFactory.BasisFunctionSelector(BasisFunction);
var integrator = NumericalIntegrationFactory.CreateIntegrator(IntegrationType);
// Evaluate every charge state XIC.
foreach (var charge in feature.ChargeStateChromatograms.Keys)
{
var gram = feature.ChargeStateChromatograms[charge];
var totalPoints = gram.Points.Count;
if (totalPoints > 1)
{
// Convert the data types, not sure why this has to be done...
// Should just using the XYData points
var x = new List<double>();
var y = new List<double>();
foreach (var xyData in gram.Points)
{
x.Add(xyData.X);
y.Add(xyData.Y);
}
// First solve for the function
var coefficients = basisFunction.Coefficients;
var solver = new LevenburgMarquadtSolver();
var report = solver.Solve(x, y, ref coefficients);
gram.FitPoints = new List<XYData>();
foreach (var datum in gram.Points)
{
var yValue = basisFunction.Evaluate(coefficients, datum.X);
gram.FitPoints.Add(new XYData(datum.X, yValue));
}
var totalSamples = 4*Math.Abs(gram.EndScan - gram.StartScan);
// Then integrate the function
// Let's integrate with 4x the number of scans
gram.Area = integrator.Integrate(basisFunction,
coefficients,
Convert.ToDouble(gram.StartScan),
Convert.ToDouble(gram.EndScan),
totalSamples);
}
}
// Then calculate all of the fits for each
foreach (var charge in feature.IsotopeChromatograms.Keys)
{
foreach (var gram in feature.IsotopeChromatograms[charge])
{
var totalPoints = gram.Points.Count;
if (totalPoints > 1)
{
// Convert the data types, not sure why this has to be done...
// Should just using the XYData points
var x = new List<double>();
var y = new List<double>();
foreach (var xyData in gram.Points)
{
x.Add(xyData.X);
y.Add(xyData.Y);
}
// First solve for the function
var coefficients = basisFunction.Coefficients;
var solver = new LevenburgMarquadtSolver();
solver.Solve(x, y, ref coefficients);
gram.FitPoints = new List<XYData>();
foreach (var datum in gram.Points)
{
var yValue = basisFunction.Evaluate(coefficients, datum.X);
gram.FitPoints.Add(new XYData(datum.X, yValue));
}
var totalSamples = 4*Math.Abs(gram.EndScan - gram.StartScan);
// Then integrate the function
// Let's integrate with 4x the number of scans
gram.Area = integrator.Integrate(basisFunction,
coefficients,
Convert.ToDouble(gram.StartScan),
Convert.ToDouble(gram.EndScan),
totalSamples);
}
}
}
}
/// <summary>
/// Scores a feature and adjusts its abundance accordingly.
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public void ScoreFeature(UMCLight feature)
{
// Get the basis function of interest
var basisFunction = BasisFunctionFactory.BasisFunctionSelector(BasisFunction);
var integrator = NumericalIntegrationFactory.CreateIntegrator(IntegrationType);
// Evaluate every charge state XIC.
foreach (var charge in feature.ChargeStateChromatograms.Keys)
{
var gram = feature.ChargeStateChromatograms[charge];
var totalPoints = gram.Points.Count;
if (totalPoints > 1)
{
// Convert the data types, not sure why this has to be done...
// Should just using the XYData points
var x = new List <double>();
var y = new List <double>();
foreach (var xyData in gram.Points)
{
x.Add(xyData.X);
y.Add(xyData.Y);
}
// First solve for the function
var coefficients = basisFunction.Coefficients;
var solver = new LevenburgMarquadtSolver();
var report = solver.Solve(x, y, ref coefficients);
gram.FitPoints = new List <XYData>();
foreach (var datum in gram.Points)
{
var yValue = basisFunction.Evaluate(coefficients, datum.X);
gram.FitPoints.Add(new XYData(datum.X, yValue));
}
var totalSamples = 4 * Math.Abs(gram.EndScan - gram.StartScan);
// Then integrate the function
// Let's integrate with 4x the number of scans
gram.Area = integrator.Integrate(basisFunction,
coefficients,
Convert.ToDouble(gram.StartScan),
Convert.ToDouble(gram.EndScan),
totalSamples);
}
}
// Then calculate all of the fits for each
foreach (var charge in feature.IsotopeChromatograms.Keys)
{
foreach (var gram in feature.IsotopeChromatograms[charge])
{
var totalPoints = gram.Points.Count;
if (totalPoints > 1)
{
// Convert the data types, not sure why this has to be done...
// Should just using the XYData points
var x = new List <double>();
var y = new List <double>();
foreach (var xyData in gram.Points)
{
x.Add(xyData.X);
y.Add(xyData.Y);
}
// First solve for the function
var coefficients = basisFunction.Coefficients;
var solver = new LevenburgMarquadtSolver();
solver.Solve(x, y, ref coefficients);
gram.FitPoints = new List <XYData>();
foreach (var datum in gram.Points)
{
var yValue = basisFunction.Evaluate(coefficients, datum.X);
gram.FitPoints.Add(new XYData(datum.X, yValue));
}
var totalSamples = 4 * Math.Abs(gram.EndScan - gram.StartScan);
// Then integrate the function
// Let's integrate with 4x the number of scans
gram.Area = integrator.Integrate(basisFunction,
coefficients,
Convert.ToDouble(gram.StartScan),
Convert.ToDouble(gram.EndScan),
totalSamples);
}
}
}
}
