public void UsePeakGuess(InitialPeakGuess guess, int channel)
{
if (guess == null) { return; }
ExperimentalRun run = DataContext as ExperimentalRun;
if (channel == 0)
{
run.Log.Channel0InitialPeakGuess = new InitialPeakGuess(guess);
}
else if (channel == 1)
{
run.Log.Channel1InitialPeakGuess = new InitialPeakGuess(guess);
}
}
public static PeakingPDF OfInitialPeakGuess(InitialPeakGuess guess)
{
return new PeakingPDF(guess.lowerbound, guess.upperbound);
}
/// <summary>
/// Construct Initial PeakGuess from CrudeZeroCrossing. Find mu from zero crossing position, sigma from inflection point
/// nbkg, nsig is from zero crossing slope. The bound is mu+-n*sigma.
/// </summary>
/// <param name="cross"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="window">smoothing parameter. indicate the size of piecewise</param>
/// <param name="nsigma">window size</param>
/// <param name="width">zero crossing fit width</param>
/// <returns></returns>
public static InitialPeakGuess OfCrudeZeroCrossing(CrudeZeroCrossing cross, double[] x, double[] y, int window = 30, double nsigma = 2.0, int width=30 )
{
InitialPeakGuess ret = new InitialPeakGuess();
double[] rawg = NP.Gradient(x, y); //this is a raw gradient
double[] g = NP.GlobalParabolicSmooth(y, window);
return InitialPeakGuess.OfCrudeZeroCrossingAndGradient(cross, x, y, g, width, nsigma);
}
/// <summary>
/// Construct initial peak guess from crude zerocrossing.
/// </summary>
/// <param name="cross"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="sg">Smooth gradient</param>
/// <param name="width"></param>
/// <param name="nsigma"></param>
/// <returns></returns>
public static InitialPeakGuess OfCrudeZeroCrossingAndGradient(CrudeZeroCrossing cross, double[] x, double[] y, double[] sg, int width=10, double nsigma = 2.0)
{
InitialPeakGuess ret = new InitialPeakGuess();
double[] g = sg;
//NP.PrintArray(g);
ZeroCrossingSlopeResult zerocrossing = PeakLocator.CrossingSlope(x, g, cross, width);
ret.mu = zerocrossing.XIntercept;
double inflection = PeakLocator.FastZeroCrossingLeftInflection(x, g, cross);
Console.WriteLine("Inflection {0}", inflection);
double sigma = ret.mu - inflection;
ret.sigma = sigma;
double lowerbound = Math.Max(0.0, zerocrossing.XIntercept - nsigma * sigma);
double upperbound = Math.Min(zerocrossing.XIntercept + nsigma * sigma, x.Last());
ret.lowerboundIndex = Math.Max(0, NP.LowerBound(x, lowerbound));
ret.upperboundIndex = Math.Min(x.Length - 1, NP.UpperBound(x, upperbound));
ret.lowerbound = x[ret.lowerboundIndex];
ret.upperbound = x[ret.upperboundIndex];
double[] xSlice = NP.Slice(x, ret.lowerboundIndex, ret.upperboundIndex + 1);//remember slice is right exclusive
double[] ySlice = NP.Slice(y, ret.lowerboundIndex, ret.upperboundIndex + 1);
lowerbound = ret.lowerbound;
upperbound = ret.upperbound;
Console.WriteLine("slope {0}, bw {1}", zerocrossing.Slope, zerocrossing.bw);
double ntotalpeak = -zerocrossing.Slope / zerocrossing.bw * Math.Pow(sigma, 3) * Math.Sqrt(2 * Math.PI);
double leftnsigma = (zerocrossing.XIntercept - lowerbound) / sigma;
double rightnsigma = (upperbound - zerocrossing.XIntercept) / sigma;
double npeakfrac = 0.5 * (SpecialFunctions.Erf(leftnsigma / Math.Sqrt(2)) + SpecialFunctions.Erf(rightnsigma / Math.Sqrt(2)));
Console.WriteLine("npeakfrac {0}", npeakfrac);
Console.WriteLine("ntotalpeak {0}", ntotalpeak);
ret.nsig = ntotalpeak * npeakfrac;
F3 gaussian = (xx, xmu, xsigma) => 1 / (xsigma * Math.Sqrt(2 * Math.PI)) * Math.Exp(-(xx - xmu) * (xx - xmu) / (2 * xsigma * xsigma));
NP.Func1 rgauss = (xx) => ntotalpeak * zerocrossing.bw * gaussian(xx, ret.mu, ret.sigma);
double[] peakamount = NP.Broadcast(rgauss, xSlice);
double[] bkgamount = NP.Broadcast((xx, yy) => xx - yy, ySlice, peakamount);
//NP.PrintArray(bkgamount);
NP.LinearFitResult bkgshape = NP.LinearFit(xSlice, bkgamount);
double m = bkgshape.m;
double c = bkgshape.c;
double bw = zerocrossing.bw;
Console.WriteLine("bkg.m {0}, bkg.c {1}", m, c);
double nbkg = 1 / bw * (m / 2.0 * (upperbound * upperbound - lowerbound * lowerbound) + c * (upperbound - lowerbound));
ret.m = m;
ret.c = c;
ret.nbkg = nbkg;
return ret;
}
public InitialPeakGuess(InitialPeakGuess guess)
{
mu = guess.mu;
sigma = guess.sigma;
m = guess.m;
c = guess.c;
nsig = guess.nsig;
nbkg = guess.nbkg;
lowerbound = guess.lowerbound;
upperbound = guess.upperbound;
lowerboundIndex = guess.lowerboundIndex;
upperboundIndex = guess.upperboundIndex;
}
public PeakFinder(double[] y, double triggerlevel = 0.4, double scalingoffset = 0, int smoothwindow = 100)
{
double scalingpower = 3.0;
x = NP.Arange(0, y.Length);
Edges = NP.Add(NP.Arange(0, y.Length), -0.5);
Debug.Assert(x.Length == y.Length, "Dimension not match");
Gradient = NP.Gradient(x, y);
SmoothGradient = NP.GlobalParabolicSmooth(Gradient, smoothwindow);
double[] scale = NP.Linspace(scalingoffset, scalingoffset + y.Length, y.Length);
scale = NP.Broadcast((xx) => Math.Pow(xx, scalingpower), scale);
ScaledGradient = NP.Multiply(SmoothGradient, scale);
TriggerValue = ScaledGradient.Max() * triggerlevel;
Crossings = PeakLocator.ZeroCrossings(ScaledGradient, TriggerValue);
InitialPeakGuess[] tmp = new InitialPeakGuess[Crossings.Length];
for (int i = 0; i < Crossings.Length; i++)
{
tmp[i] = InitialPeakGuess.OfCrudeZeroCrossingAndGradient(Crossings[i], x, y, SmoothGradient);
}
Guesses = tmp;
}
public PeakFinder()
{
Crossings = new CrudeZeroCrossing[0];
Guesses = new InitialPeakGuess[0];
x = new double[0];
y = new double[0];
Edges = new double[0];
Gradient = new double[0];
SmoothGradient = new double[0];
ScaledGradient = new double[0];
TriggerValue = 0.5;
}
/// <summary>
/// Construct PeakFitter from initialpeakguess, histogam edges+values,
/// </summary>
/// <param name="guess">Initial peak guess.</param>
/// <param name="edges">edges of the truncated histogram</param>
/// <param name="y">histogram value</param>
/// <param name="sigma">Uncertainty on Y</param>
/// <returns>PeakFitter</returns>
public static PeakFitter FromGuess(InitialPeakGuess guess, double[] edges, double[] y, double[] sigma = null)
{
PeakingPDF pdf = PeakingPDF.OfInitialPeakGuess(guess);
BinChi2 x2 = new BinChi2(pdf.Compute, edges, y, sigma);
string[] paramnames = pdf.ParamNames(); //full paramname with x
string[] pname = new string[paramnames.Length - 1]; //Dock off x
for (int i = 0; i < pname.Length; i++)
{
pname[i] = paramnames[i + 1];
}
Minuit minuit = new Minuit((FCN)(x2.Compute), pname);
minuit.SetInitialValue("mu", guess.mu);
minuit.SetInitialValue("sigma", guess.sigma);
minuit.SetInitialValue("nsig", guess.nsig);
minuit.SetInitialValue("m", guess.m);
minuit.SetInitialValue("c", guess.c);
minuit.SetInitialValue("nbkg", guess.nbkg);
PeakFitter ret = new PeakFitter() { pdf = pdf, minuit = minuit, edges=edges};
return ret;
}
public ExperimentLog()
{
Setting = new MCASetting();
MotorPosition = 0;
MCAData = new MCAData();
Temp1Start = 0;
Temp2Start = 0;
Temp1Stop = 0;
Temp2Stop = 0;
RunTime = 0;
Channel0InitialPeakGuess = new InitialPeakGuess();
Channel0FitResult = new FitResult();
Channel1InitialPeakGuess = new InitialPeakGuess();
Channel1FitResult = new FitResult();
}
