def fitting(x,y,f,p0,c0,yerr='none',qval='none'): if yerr=='none': yerr=y*0+y/y global func func=f npar=len(p0) func=def_func(npar,c0) print 'fitting with funcion: ', func print 'no of parameters: ', len(p0) # plsq = leastsq(residuals, p0, args=(y,x,yerr), col_deriv=1, maxfev=20000) if 'duri' in func: plsq= leastsq(residuals_duri_global, p0, args=(y,x,yerr,qval), col_deriv=0, ftol=1e-4, maxfev=2000000) else: plsq = leastsq(residuals, p0, args=(y,x,yerr), col_deriv=0, maxfev=20000) if npar==1: final_par = array([plsq[0]]) else: final_par = plsq[0] if 'duri' in func: yfit=0*y for i,q in enumerate(qval): q=float(q) yfit[i,:]=pyl.array(peval_duri_global(x,final_par,q),typecode='d') else: yfit=pyl.array(peval(x,final_par),typecode='d') return yfit, final_par, func
def main(): """Set up a simple recipe in a few lines.""" # The SimpleRecipe class is a type of FitRecipe. It provides attribute-like # access to variables and a residual function that can be minimized. recipe = SimpleRecipe() # Load text from file. recipe.loadtxt("data/gaussian.dat") # Set the equation. The variable "x" is taken from the data that was just # loaded. The other variables, "A", "x0" and "sigma" are turned into # attributes with an initial value of 0. recipe.setEquation("A * exp(-0.5*(x-x0)**2/sigma**2)") # We can give them other values here. recipe.A = 1 recipe.x0 = 5 recipe.sigma = 1 # We explicitly optimize the residual method of the SimpleRecipe from scipy.optimize import leastsq leastsq(recipe.residual, recipe.values) # Print the results recipe.printResults() return
def fitBrokenToStrips(self): """Fits broken-line to strip data""" # convenience views to avoid typos bStrip = (self.stripCounts > 10) if np.sum(bStrip) < 1: return x = self.stripFeHs[bStrip] y = self.stripMedns[bStrip] # could come back to this later # guess set of parameters #guess = [-0.4, -40., -240., 40.] guess = [-0.3, 0.0, -250., 0.0] # Yes this could all be looped through... meritStraight = lambda pars, x, y: oneStraight(x, pars) - y meritBroken = lambda pars, x, y: twoStraight(x, pars) - y # do the fitting self.parsStraight, self.successStraight = \ leastsq(meritStraight,guess[0:2] ,args=(x,y)) self.parsBroken, self.successBroken = \ leastsq(meritBroken,guess[:] ,args=(x,y)) # compute the sum of residuals, over the strips (not the # stars) self.chisqStraight = np.sum(meritStraight(self.parsStraight, x, y)**2) self.chisqBroken = np.sum(meritBroken(self.parsBroken, x, y)**2)
def fit_OrnsteinZernike(g6, envelope, p0=[1,1]): fitfunc = OrnsteinZernike3D errfunc = lambda p, x, y: fitfunc(p, x) - y logerrfunc = lambda p, x, y: np.log(fitfunc(p, x)) - np.log(y) p1, success = optimize.leastsq(errfunc, p0[:], args=(g6[:,0][envelope], g6[:,1][envelope])) p2, success = optimize.leastsq(logerrfunc, p0[:], args=(g6[:,0][envelope], g6[:,1][envelope])) return p1, p2
def GetBestFitSc(Method, Data, DataErrs=None): """ Compute the best fit Sc value to the data using the scipy optimize.leassq package. Also returns the reduced chi squared as a measure of the goodness of fit. """ ScInit = ( 0.8 ) # Need to have an initial for the optimizer, any valid Sc value can be used - will not impact the final value Fit_Sc = [] # Need to initialize this in case Method is incorrectly defined. Need some error handling! if Method == "raw": Fit_Sc, _, infodict, _, _ = optimize.leastsq( Residuals, ScInit, args=(Data[4], Data[2], Data[3]), full_output=True ) chi = reduced_chi_square(infodict["fvec"], Fit_Sc[0]) elif Method == "patches": Fit_Sc, _, infodict, _, _ = optimize.leastsq( Residuals, ScInit, args=(Data[10], Data[2], Data[6]), full_output=True ) chi = reduced_chi_square(infodict["fvec"], Fit_Sc[0], DataErrs) elif Method == "basins": Fit_Sc, _, infodict, _, _ = optimize.leastsq( Residuals, ScInit, args=(Data[7], Data[5], Data[6]), full_output=True ) chi = reduced_chi_square(infodict["fvec"], Fit_Sc[0], DataErrs) return Fit_Sc[0], chi
def track_all(self, problem_name, result_type): problem = self.problems[problem_name] if problem.lb is not None or problem.ub is not None: raise NotImplementedError ftol = 1e-5 if result_type == 'average time': n_runs = 10 t0 = time.time() for _ in range(n_runs): leastsq(problem.fun, problem.x0, Dfun=problem.jac, ftol=ftol, full_output=True) return (time.time() - t0) / n_runs x, cov_x, info, message, ier = leastsq( problem.fun, problem.x0, Dfun=problem.jac, ftol=ftol, full_output=True ) if result_type == 'nfev': return info['nfev'] elif result_type == 'success': return int(problem.check_answer(x, ftol)) else: raise NotImplementedError
def fit_pk_parms_1d(p0,x,f,pktype): """ Performs least squares fit to find parameters for 1d analytic functions fit to diffraction data Required Arguments: p0 -- (m) ndarray containing initial guesses for parameters for the input peaktype x -- (n) ndarray of coordinate positions f -- (n) ndarray of intensity measurements at coordinate positions x pktype -- string, type of analytic function that will be used to fit the data, current options are "gaussian","lorentzian","pvoigt" (psuedo voigt), and "split_pvoigt" (split psuedo voigt) Outputs: p -- (m) ndarray containing fit parameters for the input peaktype (see peak function help for what each parameters corresponds to) Notes: 1. Currently no checks are in place to make sure that the guess of parameters has a consistent number of parameters with the requested peak type """ fitArgs=(x,f,pktype) ftol=1e-6 xtol=1e-6 weight=np.max(f)*10.#hard coded should be changed if pktype == 'gaussian': p, outflag = optimize.leastsq(fit_pk_obj_1d, p0, args=fitArgs,Dfun=eval_pk_deriv_1d,ftol=ftol,xtol=xtol) elif pktype == 'lorentzian': p, outflag = optimize.leastsq(fit_pk_obj_1d, p0, args=fitArgs,Dfun=eval_pk_deriv_1d,ftol=ftol,xtol=xtol) elif pktype == 'pvoigt': lb=[p0[0]*0.5,np.min(x),0., 0., 0.,None] ub=[p0[0]*2.0,np.max(x),4.*p0[2],1., 2.*p0[4],None] fitArgs=(x,f,pktype,weight,lb,ub) p, outflag = optimize.leastsq(fit_pk_obj_1d_bnded, p0, args=fitArgs,ftol=ftol,xtol=xtol) elif pktype == 'split_pvoigt': lb=[p0[0]*0.5,np.min(x),0., 0., 0., 0., 0.,None] ub=[p0[0]*2.0,np.max(x),4.*p0[2],4.*p0[2],1., 1., 2.*p0[4],None] fitArgs=(x,f,pktype,weight,lb,ub) p, outflag = optimize.leastsq(fit_pk_obj_1d_bnded, p0, args=fitArgs,ftol=ftol,xtol=xtol) elif pktype == 'tanh_stepdown': p, outflag = optimize.leastsq(fit_pk_obj_1d, p0, args=fitArgs,ftol=ftol,xtol=xtol) else: p=p0 print('non-valid option, returning guess') if np.any(np.isnan(p)): p=p0 print('failed fitting, returning guess') return p
def Ajustar_Curvas_Caracteristicas(self): """Define la curva característica de la bomba a partir de los datos, todos ellos en forma de array de igual dimensión Q: caudal, m3/s h: carga, m mu: rendimiento NPSHr: carga neta de aspiración requerida por la bomba para no entrar en cavitación """ Q=r_[self.curvaActual[2]] h=r_[self.curvaActual[3]] Pot=r_[self.curvaActual[4]] NPSH=r_[self.curvaActual[5]] funcion_h = lambda p, x: p[0]*x**2+p[1]*x+p[2] # Función a ajustar residuo_h = lambda p, x, y: funcion_h(p, x) - y # Residuo inicio=r_[0, 0, 0] ajuste_h, exito_h=optimize.leastsq(residuo_h,inicio,args=(Q, h)) self.CurvaHQ=ajuste_h funcion_Pot = lambda p, x: p[0]*x**2+p[1]*x+p[2] # Función a ajustar residuo_Pot = lambda p, x, y: funcion_Pot(p, x) - y # Residuo inicio=r_[0, 0, 0] ajuste_Pot, exito_Pot=optimize.leastsq(residuo_Pot,inicio,args=(Q, Pot)) self.CurvaPotQ=ajuste_Pot funcion_NPSH = lambda p, x: p[0]+p[1]*exp(p[2]*x) # Función a ajustar residuo_NPSH = lambda p, x, y: funcion_NPSH(p, x) - y # Residuo inicio=r_[0, 0, 0] ajuste_NPSH, exito_NPSH=optimize.leastsq(residuo_NPSH,inicio,args=(Q, NPSH)) self.CurvaNPSHQ=ajuste_NPSH
def sinefit(frames, dt, sin=np.sin): """fit_parameters = sinefit(frames) Takes the output of parse_csv and runs a sine-fitting function against it. For frames with n dots, returns an n-element list of tuples of SineFit objects (x,y). e.g., fit_parameters[0] = (SineFit(for dot0 in x), SineFit(for dot0 in y)) """ # p = [amplitude, period, phase offset, y offset] fitfunc = lambda p, x: p[0] * sin(2*pi/p[1]*x + p[2]) + p[3] errfunc = lambda p, x, y: fitfunc(p, x) - y p0 = [1., 1., 0., 0.] t = np.arange(len(frames)) * dt fit_parameters = [] for idot in xrange(len(frames[0])): print 'Sine fitting: dot %d' % idot dx, dy = zip(*[(frame[idot].xpos, frame[idot].ypos) for frame in frames]) p0[0] = (max(dx)-min(dx))/2.0 p0[3] = np.mean(dx) # FIXME: "success" here is not a valid success measure px, success = optimize.leastsq(errfunc, p0, args=(t, dx)) if not success: raise "Problem with optimize for dot %d in x" % idot xfit = SineFit(*px, sin=sin) xfit.r2 = stats.mstats.pearsonr(dx, xfit.eval(t))[0] ** 2 p0[0] = (max(dy)-min(dy))/2.0 p0[3] = np.mean(dy) py, success = optimize.leastsq(errfunc, p0, args=(t, dy)) if not success: raise "Problem with optimize for dot %d in y" % idot yfit = SineFit(*py, sin=sin) yfit.r2 = stats.mstats.pearsonr(dy, yfit.eval(t))[0] ** 2 fit_parameters.append((xfit, yfit)) return fit_parameters
def update(val): min_val = x_min.val max_val = x_max.val filter = logical_and(r>min_val,r<max_val) new_r = r.compress(filter) slopes = [] for column in m_range: cms = matrix[:, column] cms = cms.compress(filter) error_min=lambda p, y, x: y - (p[0] * x + p[1]) fit=array([1, 0]) fit, success = leastsq(error_min, fit.copy(), args=(cms, new_r)) slopes.append(fit) l_fit.set_ydata(slopes[MAIN][0] * new_r + slopes[MAIN][1]) l_fit.set_xdata(new_r) regressions = [x[0] for x in slopes] slopes_plot.set_ydata(regressions) m=m_range dm=array(regressions) error_min=lambda p, dm, m: dm-p[0]*(1-exp(-p[1]*m)) p=array([6.0,1.0]) p_result, success=leastsq(error_min, p.copy(), args=(dm, m)) hline.set_ydata(p_result[0]) draw()
def LSFit(parlen,xdata,yerr,fitfun,ydata): iGuess = None MI = MaxIters derfun = None data = CreateArgs(xdata,ydata,yerr) LSfitfun,LSDerfitfun,iGuess = GetLSFuns(fitfun,derfun,iGuess,parlen) # if isinstance(ydata[0],complex):iGuess = map(complex,iGuess) if Debug: print LSDerfitfun.__name__ print LSfitfun.__name__ print np.array(iGuess) print np.array(data) if ForceNoDer: x,covar, infodict, mesg, ier=leastsq(LSfitfun,np.array(iGuess),args=np.array(data), maxfev=MI, full_output=1) else: x,covar, infodict, mesg, ier=leastsq(LSfitfun,np.array(iGuess),args=np.array(data), Dfun=LSDerfitfun, maxfev=MI, full_output=1) if float(len(ydata)-len(x)) == 0: chisqpdf = float('NaN') else: chisqpdf=sum(infodict["fvec"]*infodict["fvec"])/float(len(ydata)-len(x)) # if ier != 1: # print x # print "WARNING: Optimal parameters not found: " + mesg # raise ValueError, "Optimal parameters not found: " + mesg # print x,covar return x,covar,chisqpdf
def quick_exponential(self, x, y): # kw = dict() fitfunc = lambda p, x:p[0] * exp(p[1] * x) errfunc = lambda p, x, y: fitfunc(p, x) - y # do a linear fit first to estimate the initial guess # p0=[intercept, slope] # r = self.linear(x, y) slope, intercept = polyfit(x, y, 1) # slope, intercept = r['coefficients'] p0 = [intercept, slope] from scipy import optimize coeffs, cov_params, _infodict, _msg, ier = optimize.leastsq(errfunc, p0[:], args=(x, y), full_output=1, # maxfev = 1000 ) while ier != 1: p0 = [pi / 2.0 for pi in p0] coeffs, cov_params, _infodict, _msg, ier = optimize.leastsq(errfunc, p0[:], args=(x, y), full_output=1, # maxfev = 1000 ) coeff_errors = sqrt(diagonal(cov_params)) return coeffs, coeff_errors
def plotcurving(M, N, text, reg = 0): #choose N point randomly as x x = np.linspace(0, 1, N) #plot with the point x_show = np.linspace(0, 1, 1000) y0 = real_func(x) #G-distribution y with noise y1 = [np.random.normal(0, 0.1) + y for y in y0] p0 = np.random.randn(M) if reg == 0: plsq = leastsq(regresiduals, p0, args=(y1, x)) else: plsq = leastsq(residuals, p0, args=(y1, x)) print ('Fitting Parameters: ', plsq[0]) font = {'family' : 'serif', 'color' : 'darkred', 'weight' : 'normal', 'size' : 16, } plt.title(text, fontdict=font) plt.plot(x_show, real_func(x_show), label='real') plt.plot(x_show, fake_func(plsq[0], x_show), label='fitted curve') plt.plot(x, y1, 'bo', label='with noise') plt.legend() plt.show()
def fitting_Vthre_then_Fout(Fout, muV, sV, TvN, muGn, Gl, Cm, El,\ maxiter=1e5, ftol=1e-15,\ correction=default_correction, print_things=True,\ return_chi2=False): P = linear_fitting_of_threshold_with_firing_weight(\ Fout, muV, sV, TvN, muGn, Gl, Cm, El,\ maxiter=maxiter, xtol=ftol,\ correction=correction,\ print_things=print_things) def Res(p, muV, sV, TvN, muGn, Fout): return (Fout-erfc_func(muV, sV, TvN,\ final_threshold_func(p, muV, sV, TvN, muGn, El,\ correction=correction), Gl, Cm)) if return_chi2: P,cov,infodict,mesg,ier = leastsq( Res,P, args=(muV, sV, TvN, muGn, Fout),\ full_output=True) ss_err=(infodict['fvec']**2).sum() ss_tot=((Fout-Fout.mean())**2).sum() rsquared=1-(ss_err/ss_tot) return P, rsquared else: P = leastsq(Res, P, args=(muV, sV, TvN, muGn, Fout))[0] return P
def getKandVariance(inputRawData, inputRelations, maxIterations = 0, kSeed = 1.0, varianceSeed = 0.001, medianSide = 100, verbose = False, showSumSQ = False, alphaSeed = 1.0, useCooperativity = False): if useCooperativity: seed = [kSeed, varianceSeed, alphaSeed] bestSol, success = leastsq(residuals, seed, args = (inputRawData, inputRelations, medianSide, verbose, showSumSQ, useCooperativity), maxfev = maxIterations) else: seed = [kSeed, varianceSeed] bestSol, success = leastsq(residuals, seed, args = (inputRawData, inputRelations, medianSide, verbose, showSumSQ, useCooperativity), maxfev = maxIterations) kOut = bestSol[0] varianceOut = bestSol[1] if useCooperativity: alphaOut = bestSol[2] # kOut = k # varianceOut = variance if verbose: print() print("K = " + str(kOut)) print("Variance = " + str(varianceOut)) if useCooperativity: print("Alpha = " + str(alphaOut)) if useCooperativity: return [kOut, varianceOut, alphaOut] else: return [kOut, varianceOut]
def fit_wcs(res,x0,y0): ra,de,x,y=res[:,0],res[:,1],res[:,2],res[:,3] ra0,de0=np.mean(ra),np.mean(de) dx,dy=x-x0,y-y0 for i in range(5): w=wcs.WCS(naxis=2) w.wcs.crpix=np.array([0.0,0.0]) w.wcs.crval=np.array([ra0,de0]) w.wcs.cd=np.array([[1.0,0.0],[0.0,1.0]]) w.wcs.ctype=["RA---TAN","DEC--TAN"] w.wcs.set_pv([(2,1,45.0)]) world=np.stack((ra,de),axis=-1) pix=w.wcs_world2pix(world,1) rx,ry=pix[:,0],pix[:,1] ax,cov_q,infodict,mesg,ierr=optimize.leastsq(residual,[0.0,0.0,0.0],args=(dx,dy,rx),full_output=1) ay,cov_q,infodict,mesg,ierr=optimize.leastsq(residual,[0.0,0.0,0.0],args=(dx,dy,ry),full_output=1) ra0,de0=w.wcs_pix2world([[ax[0],ay[0]]],1)[0] w=wcs.WCS(naxis=2) w.wcs.crpix=np.array([x0,y0]) w.wcs.crval=np.array([ra0,de0]) w.wcs.cd=np.array([[ax[1],ax[2]],[ay[1],ay[2]]]) w.wcs.ctype=["RA---TAN","DEC--TAN"] w.wcs.set_pv([(2,1,45.0)]) whdr={"CRPIX1":x0,"CRPIX2":y0,"CRVAL1":ra0,"CRVAL2":de0,"CD1_1":ax[1],"CD1_2":ax[2],"CD2_1":ay[1],"CD2_2":ay[2],"CTYPE1":"RA---TAN","CTYPE2":"DEC--TAN","CUNIT1":"DEG","CUNIT2":"DEG"} return whdr
def loess_robust_parameter_estimates(data): """ Calculate Loess robust parameter estimates. :param data: A data set. :type data: list(float) :return: The parameter estimates. :rtype: list(float) """ def f(p, x, y, weights): return weights * (y - (p[0] + p[1] * x)) n = len(data) x = np.array(range(1, n + 1)) y = np.array(data) weights = np.array(tricube_weights(n)) estimates, _ = leastsq(f, [1., 1.], args=(x, y, weights)) p = estimates.tolist() residuals = (y - (p[0] + p[1] * x)) weights2 = np.array(tricube_bisquare_weights(residuals.tolist())) estimates2, _ = leastsq(f, [1., 1.], args=(x, y, weights2)) return estimates2.tolist()
def fit_data(data, nmodes): npars = 1+2*nmodes p0 = numpy.zeros(npars, dtype=numpy.float64) p1=None ; vl1=None p2=None ; vl2=None L_S = numpy.arange(360) fit_results=dict(L_S=L_S) if "vl1" in data: print data["L_S"].shape, data["vl1"].shape p1, success = optimize.leastsq(errfunc, p0[:], args=(data["L_S"][1:-1].astype(numpy.float64), data["vl1"][1:-1].astype(numpy.float64))) vl1 = fitfunc(p1, L_S) fit_results["p1"]=p1 fit_results["vl1"]=vl1 if "vl2" in data: p2, success = optimize.leastsq(errfunc, p0[:], args=(data["L_S"][1:-1].astype(numpy.float64), data["vl2"][1:-1].astype(numpy.float64))) vl2 = fitfunc(p2, L_S) fit_results["p2"]=p2 fit_results["vl2"]=vl2 return fit_results
def two_gaussian2d_fit(sx, sy, guess=[0.5,1]): """2D-Gaussian fit of samples S using a fit to the empirical CDF.""" ## UNFINISHED (I have 2 alphas unp.sign the xy projections) assert sx.size == sy.size ## Empirical CDF ecdfx = [np.sort(sx), np.arange(0.5,sx.size+0.5)*1./sx.size] ecdfy = [np.sort(sy), np.arange(0.5,sy.size+0.5)*1./sy.size] ## Analytical gaussian CDF gauss_cdf = lambda x, mu, sigma: 0.5*(1+erf((x-mu)/(np.sqrt(2)*sigma))) gauss2d_cdf = lambda X,Y,mx,sx,my,sy: gauss_cdf(X,mx,sx)*gauss_cdf(Y,my,sy) two_cdf = lambda x, m1, s1, m2, s2, a:\ a*gauss_cdf(x,m1,s1)+(1-a)*gauss_cdf(x,m2,s2) two2d_cdf = lambda X,Y, mx1, sx1, mx2, sx2, my1, sy1, my2, sy2, a:\ a*gauss2d_cdf(X,Y,mx1,sx1,my1,sy1)+(1-a)*gauss_cdf(X,Y,mx2,sx2,my2,sy2) ## Fitting the empirical CDF fitfunc = lambda p, x: two_cdf(x, *p) errfunc = lambda p, x, y: fitfunc(p, x) - y fitfunc2d = lambda p, X,Y: two2d_cdf(X,Y, *p) errfunc2d = lambda p, X,Y,Z: fitfunc2d(p, X,Y) - Z px,v = leastsq(errfunc, x0=guess, args=(ecdfx[0],ecdfx[1])) py,v = leastsq(errfunc, x0=guess, args=(ecdfy[0],ecdfy[1])) print("2D Two-Gaussians CDF fit", px, py) mux1, sigmax1, mux2, sigmax2, alphax = px muy1, sigmay1, muy2, sigmay2, alphay = py return mu1, sigma1, mu2, sigma2, alpha
def pulseIntFit(t, pulseInt, shape='gaussian'): ''' Fit the pulse with a specific pulse shape * t: time vector * pulseInt: Pulse intensity * shape: Pulse shape ('gaussian', 'sech', 'parabolic') ''' # Distance to the target function errfunc_g = lambda p, t, y: pulse.gaussianPulseCmpt(t, p) - y errfunc_s = lambda p, t, y: pulse.sechPulseCmpt(t, p) - y errfunc_p = lambda p, t, y: pulse.parabolicPulseFitCmpt(t, p) - y # Initial guess for the parameters p0_g = [5.0, 0.0, 1.0, 0.0] p0_s = [5.0, 0.0, 1.0, 0.0] p0_p = [5.0, 0.0, pulseInt.max()] # Fit with rge least square method [p, success] = { 'gaussian': lambda: leastsq(errfunc_g, p0_g[:], args=(t, pulseInt)), 'sech': lambda: leastsq(errfunc_s, p0_s[:], args=(t, pulseInt)), 'parabolic': lambda: leastsq(errfunc_p, p0_p[:], args=(t, pulseInt)), }[shape]() fit = { 'gaussian': lambda: pulse.gaussianPulseCmpt(t, p), 'sech': lambda: pulse.sechPulseCmpt(t, p), 'parabolic': lambda: pulse.parabolicPulseFitCmpt(t, p), }[shape]() return fit
def gaussian_fit_curve(x, y, mu0=0, sigma0=1, a0=None, return_all=False, **kwargs): """Gaussian fit of curve (x,y). If a0 is None then only (mu,sigma) are fitted (to a gaussian density). `kwargs` are passed to the leastsq() function. If return_all=False then return only the fitted (mu,sigma) values If return_all=True (or full_output=True is passed to leastsq) then the full output of leastsq is returned. """ if a0 is None: gauss_pdf = lambda x, m, s: np.exp(-((x-m)**2)/(2*s**2))/\ (np.sqrt(2*np.pi)*s) err_fun = lambda p, x, y: gauss_pdf(x, *p) - y res = leastsq(err_fun, x0=[mu0, sigma0], args=(x, y), **kwargs) else: gauss_fun = lambda x, m, s, a: a*np.sign(s)*np.exp(-((x-m)**2)/(2*s**2)) err_fun = lambda p, x, y: gauss_fun(x, *p) - y res = leastsq(err_fun, x0=[mu0, sigma0, a0], args=(x, y), **kwargs) if 'full_output' in kwargs: return_all = kwargs['full_output'] mu, sigma = res[0][0], res[0][1] if return_all: return res return mu, sigma
def __solver__(self, p): p.xk = p.x0.copy() p.fk = asfarray((p.f(p.x0)) ** 2).sum().flatten() p.iterfcn() if p.istop: p.xf, p.ff = p.xk, p.fk return if p.userProvided.df: xf, cov_x, infodict, mesg, ier = leastsq(p.f, p.x0, Dfun=p.df, xtol = p.xtol, ftol = p.ftol, maxfev = p.maxFunEvals, full_output = 1) else: xf, cov_x, infodict, mesg, ier = leastsq(p.f, p.x0, xtol = p.xtol, maxfev = p.maxFunEvals, epsfcn = p.diffInt, ftol = p.ftol, full_output = 1) if ier == 1: p.istop = 1000 else: p.istop = -1000 p.msg = mesg ff = asfarray((p.f(xf)) ** 2).sum().flatten() p.xk = xf p.fk = ff p.xf = xf p.ff = ff p.iterfcn()
def fitDSTFMRscan(dataframe,f,i,theta_wi): positive=dataframe[dataframe.field>0.01] posmin= positive.l1x.argmin() posupper = posmin+30 poslower = posmin-30 positive = dataframe[poslower:posupper] #print(positive) #print('positive') negative=dataframe[dataframe.field<-0.01] negmin= negative.l1x.argmin() negative = dataframe[negmin-30:negmin+30] #print(negative) lsqpos = leastsq(deriv_stfmr_with_i_residual, theta_wi, args=(positive.field, f,i, positive.l1x*10**6), maxfev=10000, full_output = 1, ) lsqneg = leastsq(deriv_stfmr_with_i_residual, theta_wi, args=(abs(negative.field), f,i, negative.l1x*10**6), maxfev=10000, full_output = 1, ) poptpos, coptpos, _,_,_ =lsqpos poptneg,coptneg,_,_,_ = lsqneg alpha_pos =poptpos[0] alpha_neg =poptneg[0] Meff_neg = poptneg[1] Meff_pos = poptpos[1] hdcpos = poptpos[4] hdcneg = poptneg[4] kpos = poptpos[5] kneg = poptneg[5] cxeven = (poptpos[2]-poptneg[2])/2 cxodd = (poptpos[2]+poptneg[2])/2 czeven = (poptpos[3]-poptneg[3])/2 czodd = (poptpos[3]+poptneg[3])/2 return (np.array([alpha_pos,alpha_neg,Meff_pos,Meff_neg,hdcpos,hdcneg,kpos,kneg,cxeven,cxodd,czeven,czodd]),lsqpos,lsqneg)
def sendCalibration(self): n = len(self.pointList) data = numpy.empty((3, n)) for i in range(n): data[:,i] = self.pointList[i][1] print "Data:", data ## find coefficients for function T = f(V) # R = R1 * ((1023 / V) - 1) # 1/T = A + B log(R) + C log(R)^3 ## the parameter R1 gets absorbed by A, so there are only 3 variables. def fn(v, x): R = (1023. / x) - 1. lnR = numpy.log(R) return 1.0 / (v[0] + v[1] * lnR + v[2] * lnR * lnR * lnR) def erf(v, x, y): return fn(v, x)-y guess = numpy.array([0.04, 0.03, -0.01]) fit1 = leastsq(erf, guess, args=(data[1], data[0])) fit2 = leastsq(erf, guess, args=(data[2], data[0])) print "Fit:" print fit1 print fit2 cmd = 'c' + fit1[0].astype(numpy.float32).tostring() + fit2[0].astype(numpy.float32).tostring() self.ArduinoWrite(cmd)
def bmfit_1D(x, y): p = [0, 0, 0, 0] p = sec_order_fit(x, y) return leastsq(residuals, p, args=(y, x), full_output=1)
def runclient(args, pars): # load single pulse data singlePulse = np.load('singlePulse.npz')['avePulse'] # make it match the length of the Acqiris trace (this will change) singlePulse = np.pad(singlePulse, (7500, 7500), 'constant', constant_values=(0, 0)) # normalize trace to peak so that the amplitude we fit is proportional to peak values on MCP trace singlePulse = singlePulse / np.max(singlePulse) # location of peak in reference trace peak1 = np.argmax(singlePulse) # optimization function def optFunc(p, xdata, ydata, pulse): a1, a2, x1, x2 = p err = np.abs(ydata - (a1 * np.interp(xdata - x1, xdata, pulse) + a2 * np.interp(xdata - x2, xdata, pulse))) return err # function that returns curve def evalFunc(p, xdata, pulse): a1, a2, x1, x2 = p curve = a1 * np.interp(xdata - x1, xdata, pulse) + a2 * np.interp( xdata - x2, xdata, pulse) return curve # expected delay based on what we asked from the accelerator delay = args.delay # initialize fitting parameters (actually I don't think these are being used...) x1_0 = 4478.0 # based on visual inspection of data x2_0 = x1_0 + delay / .125 # based on expected delay time a1_0 = 1.0 # arbitrary a2_0 = 1.0 # arbitrary p0 = [a1_0, a2_0, x1_0, x2_0] # put into array # array for interpolation xdata = np.arange(0, 20000) # where to find the data sh_mem = pars['live'] expName = pars['expName'] runNum = args.run runString = 'exp=' + expName + ':run=' + runNum + ':smd' # needed for shared memory access calibDir = '/reg/d/psdm/sxr/' + expName + '/calib' # check whether we're reading from shared memory or old run ds = [] if sh_mem: runString += ':dir=/reg/d/ffb/sxr/' + expName + '/xtc:live' ds = DataSource(''.join(['shmem=psana.', str(rank % 8), ':stop=no'])) setOption('psana.calib-dir', calibDir) else: ds = DataSource(runString) # acqiris detector acq = Detector('Acq02') # number of events between updates (set in MCP_driver.py) updateEvents = pars['updateEvents'] # initialize instance of the mpidata class for communication with the master process md = mpidata() # counter (local per core) n1 = -1 # initialize arrays x1Array = np.empty(0) x2Array = np.empty(0) a1Array = np.empty(0) a2Array = np.empty(0) # initialize acqiris trace wf = np.zeros(20000) # event loop for nevent, evt in enumerate(ds.events()): # check if we've reached the event limit if nevent == args.noe: break if nevent % (size - 1) != rank - 1: continue # different ranks look at different events # skip damaged events if acq.waveform(evt) is None: continue # damage # update counter n1 += 1 # get MCP trace wf = acq.waveform(evt)[0].flatten() # subtract background (assume at least 10000 data points before pulse) wf = wf - np.mean(wf[0:10000]) # guesses for fit parameters # peak of first pulse p0a1 = np.max(wf) # time position of first pulse (relative to reference) p0x1 = np.argmax(wf) - peak1 # subtract first pulse guess from MCP trace wf2 = wf - evalFunc([p0a1, 0, p0x1, 0], xdata, singlePulse) # peak of second pulse p0a2 = np.max(wf2) # time position of second pulse (relative to reference) p0x2 = np.argmax(wf2) - peak1 # put guesses into a list p0 = [p0a1, p0a2, p0x1, p0x2] # fit the curve (put small limit on number of function evaluations for speed) p = optimization.leastsq(optFunc, p0, args=(xdata, wf, singlePulse), maxfev=10) # update arrays based on current event a1Array = np.append(a1Array, p[0][0]) a2Array = np.append(a2Array, p[0][1]) x1Array = np.append(x1Array, p[0][2]) x2Array = np.append(x2Array, p[0][3]) if ((n1 + 1) % updateEvents == 0 ): # send mpi data object to master when desired # include fit to current trace to make sure fit looks good fit1 = evalFunc([p0a1, p0a2, p0x1, p0x2], xdata, singlePulse) md.addarray('wf', wf) md.addarray('fit', fit1) md.addarray('a1', a1Array) md.addarray('a2', a2Array) md.addarray('delay', np.abs(x1Array - x2Array) * .125) md.small.event = nevent md.send() # reset counter n1 = -1 # reinitialize arrays a1Array = np.empty(0) a2Array = np.empty(0) x1Array = np.empty(0) x2Array = np.empty(0) md.endrun()
def alignY(datalists,xmin,xmax,zeropoint=0,p0=[1,0,1.5,-2.5],func='power'): """ *** WILL BE REWRITTEN *** Align two datasets by shifting Y coordinate. Works on multiple data lists at a time. Each dataset is shifted to match with the previous dataset AFTER the previous one has already been shifted. e.g. for the third dataset y_new = zeropoint + shifts[1]*shifts[2]*y The shifts between datasets are multiplicative, the first dataset is shifted additively by the keyword zeropoint. At least 3 points of overlap are required! @param datalists: two or more 2d lists of data giving (x,y) @type datalists: list[list[(.,.)]] @param xmin: the lower boundar(y)(ies) of the overlapping region, used for alignment. Must be 1 value for 2 datasets, n-1 values for more @type xmin: float or list @param xmax: the upper boundar(y)(ies) of the overlapping region, used for alignment. Must be 1 value for 2 datasets, n-1 values for more @type xmax: float or list @keyword zeropoint: The first dataset is shifted additively with this value (default: 0) @type zeropoint: float @keyword p0: initial parameters for fitting function definition (default: [1,0,1.5,-2.5]) @type p0: list @return: The datasets are returned as given, but with shifted Y-values, and the shifts used (first value additively, rest multiplicatively) @rtype: (list[list[(.,.)]], list) """ #- zeropoint correction shifts = [zeropoint] current_data = array(datalists[0]) corrected = [[coord + array([0,zeropoint]) for coord in current_data]] #- Power law is fitted to overlapping xrange for both datasets with leastsq #- x of second list is evaluated with both functions #- second list's y values are corrected by the mean of the ratios of the #- two function evaluations for i in xrange(len(datalists)-1): p_lsqlist1 = leastsq(Interpol.getResiduals,p0,\ args=([x for x in array(corrected[i])[:,0] if x >= xmin[i] and x <= xmax[i]],\ [coord[1] for coord in array(corrected[i]) if coord[0] >= xmin[i] and coord[0] <= xmax[i]],\ func),\ maxfev=2000)[0] p_lsqlist2 = leastsq(Interpol.getResiduals,p0,\ args=([x for x in array(datalists[i+1])[:,0] if x >= xmin[i] and x <= xmax[i]],\ [coord[1] for coord in array(datalists[i+1]) if coord[0] >= xmin[i] and coord[0] <= xmax[i]],\ func),\ maxfev=2000)[0] f1x2 = Interpol.pEval([x for x in array(datalists[i+1])[:,0] if x >= xmin[i] and x <= xmax[i]], p_lsqlist1,func) f2x2 = Interpol.pEval([x for x in array(datalists[i+1])[:,0] if x >= xmin[i] and x <= xmax[i]],\ p_lsqlist2,func) shifts.append(mean(f1x2/f2x2)) corrected.append([coord*array([1,shifts[i+1]]) for coord in array(datalists[i+1])]) return corrected,shifts
def fit_SaturationFunction(xdata,ydata,p0): plsq = leastsq(_residuals_SaturationFunction, p0, args=(xdata,ydata)) return plsq
def fit_AOMfunction(xdata,ydata,p0): plsq = leastsq(_residuals_AOMfunction, p0, args=(xdata,ydata)) return plsq
def FitLorrentz1(x, y, xmin=445, xmax=447, DEBUGFILE=False): ii = np.nonzero(np.logical_and(x >= xmin, x <= xmax))[0] xm = x ym = y x = x[ii] y = y[ii] a0 = np.max(y) imx = np.argmax(y) x0 = x[imx] ilo = imx - 1 ihi = imx + 1 #Estimate the FWHM while ilo > 1 and y[ilo] > 0.5 * a0: ilo = ilo - 1 while ihi < ii.shape[0] - 1 and y[ihi] > 0.5 * a0: ihi = ihi + 1 gam0 = np.abs(x[ihi] - x[ilo]) #Estimate the initial background (form <y = m*x + b>) m = 0 b = 0 #Define the function to minimize via the least-squares method def ObjFxn(xf): A = np.abs(xf[0]) x0 = xf[1] gam = xf[2] m = xf[3] b = xf[4] return y - A * np.power(gam, 2) / ((np.power( (x - x0), 2) + np.power(gam, 2))) - b #ne pas mettre A au mumerateur, ca compliaue les calculs #Do the fit x0 = np.array([a0, x0, gam0, m, b]) xfit = spop.leastsq(ObjFxn, x0)[0] #For debugging purposes, plot each fit individually if DEBUGFILE: #Define the fit function def FitFxn(xf): A = np.abs(xf[0]) x0 = xf[1] gam = xf[2] m = xf[3] b = xf[4] return lambda x: A * np.power(gam, 2) / ((np.power( (x - x0), 2) + np.power(gam, 2))) + b xf = np.linspace(xmin, xmax, 1000) fit = FitFxn(xfit) plt.plot(xm, ym, 'ko', ms=4, label='Data') plt.plot(xm, fit(xm), 'r-', lw=1.5, label='Fit') plt.legend(loc='upper left') plt.xlabel('wavelength [nm]') plt.ylabel('Count rate [1/s]') plt.savefig('DEBUGFILE/%s' % (DEBUGFILE)) plt.clf() #Return the fit parameters return [xfit[0], xfit[1], fit(xm)]
#Se creó la función R para ajustar los datos obtenidos def R(x): r = np.zeros(N) for i in range(0, N): r[i] = ydata[i] - (x[0] * np.sin(tdata[i] * x[1] + x[2]) + x[3] * tdata[i]) return np.transpose(r) #Se creó el vector de datos iniciales x0 = np.array([8.98, 0.95, 0.60, 0.30]) #Se aplicó la funcion leastsq para R y datos iniciales x0 xoptimo = leastsq(R, x0) print(xobjetivo) print(xoptimo[0]) #Se utilizó solo la primera componente de la salida de la funcion leastsq xbacan = np.array(xoptimo[0]) #Se creó una función que permitiera el ajuste de datos con lo obtenido en la salida de leastsq newdata = xbacan[0] * np.sin(xbacan[1] * tdata + xbacan[2]) + tdata * xbacan[3] #Graficar datos originales vs leastsq plt.plot(tdata, ydata, color='blue', marker='.', linestyle='', markersize=1) plt.plot(tdata, newdata, color='red', marker='.', linestyle='', markersize=1) plt.show()
def fit(self, order=(0, 0), start_params=None, method="ls", **optkwds): ''' Estimate lag coefficients of an ARIMA process. Parameters ---------- order : sequence p,d,q where p is the number of AR lags, d is the number of differences to induce stationarity, and q is the number of MA lags to estimate. method : str {"ls", "ssm"} Method of estimation. LS is conditional least squares. SSM is state-space model and the Kalman filter is used to maximize the exact likelihood. rhoy0, rhoe0 : array_like (optional) starting values for estimation Returns ------- (rh, cov_x, infodict, mesg, ier) : output of scipy.optimize.leastsq rh : estimate of lag parameters, concatenated [rhoy, rhoe] cov_x : unscaled (!) covariance matrix of coefficient estimates ''' if not hasattr(order, '__iter__'): raise ValueError("order must be an iterable sequence. Got type \ %s instead" % type(order)) p, q = order self.nar = p # needed for geterrors, needs cleanup self.nma = q ## if d > 0: ## raise ValueError("Differencing not implemented yet") ## # assume no constant, ie mu = 0 ## # unless overwritten then use w_bar for mu ## Y = np.diff(endog, d, axis=0) #TODO: handle lags? x = self.endog.squeeze() # remove the squeeze might be needed later # def errfn( rho): # #rhoy, rhoe = rho # rhoy = np.concatenate(([1], rho[:p])) # rhoe = np.concatenate(([1], rho[p:])) # etahatr = signal.lfilter(rhoy, rhoe, x) # #print rho,np.sum(etahatr*etahatr) # return etahatr #replace with start_params if start_params is None: arcoefs0 = 0.5 * np.ones(p) macoefs0 = 0.5 * np.ones(q) start_params = np.r_[arcoefs0, macoefs0] method = method.lower() if method == "ls": #update optim_kwds = dict(ftol=1e-10, full_output=True) optim_kwds.update(optkwds) #changes: use self.geterrors (nobs,): # rh, cov_x, infodict, mesg, ier = \ # optimize.leastsq(errfn, np.r_[rhoy0, rhoe0],ftol=1e-10,full_output=True) rh, cov_x, infodict, mesg, ier = \ optimize.leastsq(self.geterrors, start_params, **optim_kwds) #TODO: need missing parameter estimates for LS, scale, residual-sdt #TODO: integrate this into the MLE.fit framework? elif method == "ssm": pass else: #this is also conditional least squares # fmin_bfgs is slow or does not work yet errfnsum = lambda rho: np.sum(self.geterrors(rho)**2) #xopt, {fopt, gopt, Hopt, func_calls, grad_calls optim_kwds = dict(maxiter=2, full_output=True) optim_kwds.update(optkwds) rh, fopt, gopt, cov_x, _,_, ier = \ optimize.fmin_bfgs(errfnsum, start_params, **optim_kwds) infodict, mesg = None, None self.params = rh self.ar_est = np.concatenate(([1], -rh[:p])) self.ma_est = np.concatenate(([1], rh[p:p + q])) #rh[-q:])) doesnt work for q=0, added p+q as endpoint for safety if var is included self.error_estimate = self.geterrors(rh) return rh, cov_x, infodict, mesg, ier
def fit(p0,x,y,res): p1=leastsq(res, c, args=(x, y))[0] return p1
given a vector of parameters and volumes, return a vector of energies. equation From PRB 28,5480 (1983) ''' E0 = parameters[0] B0 = parameters[1] BP = parameters[2] V0 = parameters[3] E = E0 + B0*vol/BP*(((V0/vol)**BP)/(BP-1)+1) - V0*B0/(BP-1.) return E # and we define an objective function that will be minimized def objective(pars,y,x): #we will minimize this function err = y - Murnaghan(pars,x) return err x0 = [e0, b0, bP, v0] #initial guesses in the same order used in the Murnaghan function murnpars, ier = leastsq(objective, x0, args=(e,v)) #this is from scipy #now we make a figure summarizing the results plt.plot(v,e,'ro') plt.plot(vfit, a*vfit**2 + b*vfit + c,'--',label='parabolic fit') plt.plot(vfit, Murnaghan(murnpars,vfit), label='Murnaghan fit') plt.xlabel('Volume ($\AA^3$)') plt.ylabel('Energy (eV)') plt.legend(loc='best') #add some text to the figure in figure coordinates ax = plt.gca() plt.text(0.4, 0.5, 'Min volume = {0:1.2f} $\AA^3$'.format(murnpars[3]), transform = ax.transAxes) plt.text(0.4, 0.4, 'Bulk modulus = {0:1.2f} eV/$\AA^3$ = {1:1.2f} GPa'.format(murnpars[1], murnpars[1]*160.21773), transform = ax.transAxes) plt.savefig('images/a-eos.png')
def doselfconsistent(self): iteration = 0 u_diff = 1.0 convergence_threshold = 1e-5 print("RHF energy =", self.ints.fullEhf) while (u_diff > convergence_threshold): iteration += 1 print("DMET iteration", iteration) umat_old = np.array(self.umat, copy=True) rdm_old = self.transform_ed_1rdm( ) # At the very first iteration, this matrix will be zero # Find the chemical potential for the correlated impurity problem start_ed = time.time() if ((self.method == 'CC') and (self.CC_E_TYPE == 'CASCI')): self.mu_imp = 0.0 self.doexact(self.mu_imp) elif ((self.method == 'CASSCF') and (self.CC_E_TYPE == 'CASCI')): self.mu_imp = 0.0 self.doexact(self.mu_imp) elif ((self.method == 'RHF') and (self.CC_E_TYPE == 'CASCI')): self.mu_imp = 0.0 self.doexact(self.mu_imp) else: self.mu_imp = optimize.newton(self.numeleccostfunction, self.mu_imp) print(" Chemical potential =", self.mu_imp) stop_ed = time.time() self.time_ed += (stop_ed - start_ed) print(" Energy =", self.energy) # self.verify_gradient( self.square2flat( self.umat ) ) # Only works for self.doSCF == False!! if (self.SCmethod != 'NONE' and not (self.altcostfunc)): self.hessian_eigenvalues(self.square2flat(self.umat)) # Solve for the u-matrix start_cf = time.time() if (self.altcostfunc and self.SCmethod == 'BFGS'): result = optimize.minimize( self.alt_costfunction, self.square2flat(self.umat), jac=self.alt_costfunction_derivative, options={'disp': False}) self.umat = self.flat2square(result.x) elif (self.SCmethod == 'LSTSQ'): result = optimize.leastsq(self.rdm_differences, self.square2flat(self.umat), Dfun=self.rdm_differences_derivative, factor=0.1) self.umat = self.flat2square(result[0]) elif (self.SCmethod == 'BFGS'): result = optimize.minimize(self.costfunction, self.square2flat(self.umat), jac=self.costfunction_derivative, options={'disp': False}) self.umat = self.flat2square(result.x) self.umat = self.umat - np.eye(self.umat.shape[0]) * np.average( np.diag( self.umat)) # Remove arbitrary chemical potential shifts if (self.altcostfunc): print(" Cost function after convergence =", self.alt_costfunction(self.square2flat(self.umat))) else: print(" Cost function after convergence =", self.costfunction(self.square2flat(self.umat))) stop_cf = time.time() self.time_cf += (stop_cf - start_cf) # Possibly print the u-matrix / 1-RDM if self.print_u: self.print_umat() if self.print_rdm: self.print_1rdm() # Get the error measure u_diff = np.linalg.norm(umat_old - self.umat) rdm_diff = np.linalg.norm(rdm_old - self.transform_ed_1rdm()) self.umat = self.relaxation * umat_old + ( 1.0 - self.relaxation) * self.umat print(" 2-norm of difference old and new u-mat =", u_diff) print(" 2-norm of difference old and new 1-RDM =", rdm_diff) print("******************************************************") if (self.SCmethod == 'NONE'): u_diff = 0.1 * convergence_threshold # Do only 1 iteration print("Time cf func =", self.time_func) print("Time cf grad =", self.time_grad) print("Time dmet ed =", self.time_ed) print("Time dmet cf =", self.time_cf) return self.energy
# Motore 1 kt = 60.3e-6 rp = 0.75 / 26.17585 N = 1 x = np.loadtxt('MOT') t = x[200:264, 0] y = x[200:264, 1] t = t - t[0] y = y - y[0] t = np.arange(0, ts * (len(t)), ts) U0 = 1500 p0 = [1., 4.] y1 = y / U0 plsq = leastsq(residuals, p0, args=(y1, t)) M = kt / plsq[0][0] # Motor Inertia d = plsq[0][1] * M # Motor friction g = tf([kt / M], [1, d / M, 0]) # Transfer function Y, T = step(g, t) plot(T, Y) plot(t, y1) #show() # Plant AP = [[0, 1], [0, -d / M]] BP = [[0], [kt / M]] CP = [1, 0]
def fit_ellipse_amorphous_ring(data,center,fitradii,p0=None,mask=None): """ Fit the amorphous halo of a diffraction pattern, including any elliptical distortion. The fit function is:: f(x,y; I0,I1,sigma0,sigma1,sigma2,c_bkgd,x0,y0,A,B,C) = Norm(r; I0,sigma0,0) + Norm(r; I1,sigma1,R)*Theta(r-R) Norm(r; I1,sigma2,R)*Theta(R-r) + c_bkgd where * (x,y) are cartesian coordinates, * r is the radial coordinate, * (I0,I1,sigma0,sigma1,sigma2,c_bkgd,x0,y0,R,B,C) are parameters, * Norm(x;I,s,u) is a gaussian in the variable x with maximum amplitude I, standard deviation s, and mean u * Theta(x) is a Heavyside step function * R is the radial center of the double sided gaussian, derived from (A,B,C) and set to the mean of the semiaxis lengths The function thus contains a pair of gaussian-shaped peaks along the radial direction of a polar-elliptical parametrization of a 2D plane. The first gaussian is centered at the origin. The second gaussian is centered about some finite R, and is 'two-faced': it's comprised of two half-gaussians of different standard deviations, stitched together at their mean value of R. This Janus (two-faced ;p) gaussian thus comprises an elliptical ring with different inner and outer widths. The parameters of the fit function are * I0: the intensity of the first gaussian function * I1: the intensity of the Janus gaussian * sigma0: std of first gaussian * sigma1: inner std of Janus gaussian * sigma2: outer std of Janus gaussian * c_bkgd: a constant offset * x0,y0: the origin * A,B,C: The ellipse parameters, in the form Ax^2 + Bxy + Cy^2 = 1 Args: data (2d array): the data center (2-tuple of numbers): the center (x0,y0) fitradii (2-tuple of numbers): the inner and outer radii of the fitting annulus p0 (11-tuple): initial guess parameters. If p0 is None, the function will compute a guess at all parameters. If p0 is a 11-tuple it must be populated by some mix of numbers and None; any parameters which are set to None will be guessed by the function. The parameters are the 11 parameters of the fit function described above, p0 = (I0,I1,sigma0,sigma1,sigma2,c_bkgd,x0,y0,A,B,C). Note that x0,y0 are redundant; their guess values are the x0,y0 values passed to the main function, but if they are passed as elements of p0 these will take precendence. mask (2d array of bools): only fit to datapoints where mask is True Returns: (2-tuple comprised of a 5-tuple and an 11-tuple): Returns a 2-tuple. The first element is the ellipse parameters need to elliptically parametrize diffraction space, and is itself a 5-tuple: * **x0**: x center * **y0**: y center, * **a**: the semimajor axis length * **b**: the semiminor axis length * **theta**: tilt of a-axis w.r.t x-axis, in radians The second element is the full set of fit parameters to the double sided gaussian function, described above, and is an 11-tuple """ if mask is None: mask = np.ones_like(data).astype(bool) assert data.shape == mask.shape, "data and mask must have same shapes." x0,y0 = center ri,ro = fitradii # Get data mask Nx,Ny = data.shape yy,xx = np.meshgrid(np.arange(Ny),np.arange(Nx)) rr = np.hypot(xx-x0,yy-y0) _mask = ((rr>ri)*(rr<ro)).astype(bool) _mask *= mask # Make coordinates, get data values x_inds, y_inds = np.nonzero(_mask) vals = data[_mask] # Get initial parameter guesses I0 = np.max(data) I1 = np.max(data*mask) sigma0 = ri/2. sigma1 = (ro-ri)/4. sigma2 = (ro-ri)/4. c_bkgd = np.min(data) # To guess R, we take a radial integral q,radial_profile = radial_integral(data,x0,y0,1) R = q[(q>ri)*(q<ro)][np.argmax(radial_profile[(q>ri)*(q<ro)])] # Initial guess at A,B,C A,B,C = convert_ellipse_params_r(R,R,0) # Populate initial parameters p0_guess = tuple([I0,I1,sigma0,sigma1,sigma2,c_bkgd,x0,y0,A,B,C]) if p0 is None: _p0 = p0_guess else: assert len(p0)==11 _p0 = tuple([p0_guess[i] if p0[i] is None else p0[i] for i in range(len(p0))]) # Perform fit p = leastsq(double_sided_gaussian_fiterr, _p0, args=(x_inds, y_inds, vals))[0] # Return _x0,_y0 = p[6],p[7] _A,_B,_C = p[8],p[9],p[10] _a,_b,_theta = convert_ellipse_params(_A,_B,_C) return (_x0,_y0,_a,_b,_theta),p
def fit_test(x, y): params = np.zeros(len(name_label_dict)) wd = 1e-5 error = lambda p: np.concatenate((Count_soft(x, p) - y, wd * p), axis=None) p, success = opt.leastsq(error, params) return p
# initial variables(M, P & Q) vars = [sum(sales), 0.002, 0.002] # residual (error) function def residual(vars, t, sales): M = vars[0] P = vars[1] Q = vars[2] Bass = M * (((P + Q)**2 / P) * np.exp(-(P + Q) * t)) / (1 + (Q / P) * np.exp(-(P + Q) * t))**2 return (Bass - (sales)) # non linear least square fitting varfinal, success = leastsq(residual, vars, args=(t, sales)) # estimated coefficients m = varfinal[0] p = varfinal[1] q = varfinal[2] print(varfinal) #sales plot (pdf) #time interpolation tp = (np.linspace(1.0, float(len(sales)) * 10, num=len(sales) * 10)) / 10 cofactor = np.exp(-(p + q) * tp) sales_pdf = m * (((p + q)**2 / p) * cofactor) / (1 + (q / p) * cofactor)**2 plt.plot(tp, sales_pdf, t, sales) plt.title('Keywords pdf') plt.legend(['Fit', 'True'])
xtol = 1e-6 fitArgs = (x, f, pktype, num_pks) tth = matl.planeData.getTTh() * 180. / np.pi p0 = np.zeros([num_tth, 4]) for ii in np.arange(num_tth): pt = np.argmin(np.abs(x - tth[ii])) p0[ii, :] = [f[pt], tth[ii], 0.1, 0.5] p, outflag = optimize.leastsq(fit_pk_obj_1d_mpeak, p0, args=fitArgs, ftol=ftol, xtol=xtol) p = np.reshape(p, [num_pks, p.shape[0] / num_pks]) f_fit = np.zeros(len(x)) for ii in np.arange(num_pks): f_fit = f_fit + pkfuncs._pvoigt1d_no_bg(p[ii], x) #plt.plot(x,f,'x') #plt.hold('true') #plt.plot(x,f_fit) ax[1].plot(x, f_fit, 'm+', ms=1) #%%
print("Iteration:" , step[0]) return func(W, x) - y # In[6]: W0 = [100, 2] step = [0] # 把error 函数中其他参数打包到args中 ''' func:误差函数 x0:表示函数的参数 args()表示数据点 ''' lst = leastsq(error, W0, args=(X, Y, step)) k, b = lst[0] print("K = ", k, "b = ", b) # 拟合结果 # In[7]: X_points = np.linspace(0, 10, 100) Y_points = k * X_points + b plt.plot(X, Y, 'bo', label = 'Data with noise') plt.plot(X_points, Y_points, 'r', label = 'Fitting data') plt.legend()
def doAll(file_location, filename, function_name="IdealFunc"): ''' Fits, plots, and saves Ster-Gerlac data Input: file path, fit function Output: graph, final fit parameters, initial guess, covariance matrix, chi2. ''' function_in_use = FUNCTION_DICT[function_name] residual_in_use = RESIDUAL_DICT[function_name] print "\n\n -------- Processing file %s" % filename x, y = fSG.load_data(file_location, filename) #do fit pname = ['A', 'Center', 'q', 'D'] param0 = [10, -0.0005, 4.2, 0.05] #initial params plsq = leastsq(residual_in_use, param0, args=(y, x), maxfev=10000, full_output=True) paramFinal, err = plsq[0], plsq[1] fit = function_in_use(paramFinal, x) initialGuess = function_in_use(param0, x) #show results and plot fig = pl.figure() pl.plot(x, y, 'bo', label=' data') pl.plot(x, fit, 'r', label='fit') pl.plot(x, initialGuess, 'g', label='initial guess') pl.legend() pl.xlabel('Distance [mm]') pl.ylabel('Voltage [V]') pl.title('%s at %s' % (function_name, filename)) txt_final = 'Final parameters' print txt_final, paramFinal txt_initial = 'Initial guess' print txt_initial, param0 txt_cov = 'Covariance matrix' print txt_cov, err chi2 = sum(residual_in_use(paramFinal, y, x)**2) txt_chi2 = 'chi2 ' print 'chi2 ', chi2 #save graph graph_name = "%s-%s.png" % (function_name, filename) output_name = os.path.join(file_location, graph_name) print "Saving figure to ", output_name pl.savefig(output_name) #save fit info text_output_name = os.path.join(file_location, graph_name[:-3] + "txt") print "Saving fit info to ", text_output_name out_f = open(text_output_name, "wb") out_f.write(graph_name[:-4] + "\n") out_f.write(txt_initial + "\n") out_f.write(str(param0) + "\n") out_f.write(txt_final + "\n") out_f.write(str(paramFinal) + "\n") out_f.write(txt_cov + "\n") out_f.write(str(err) + "\n") out_f.write(txt_chi2 + "\n") out_f.write(str(chi2) + "\n") out_f.write("output of least square fit" + "\n") for piece in plsq: out_f.write(str(piece) + "\n") out_f.close()
def fitgaussian(y, x=None, guess=None, lsargs={"maxfev": 2000}, minout=None): ''' Fits an N-dimensional Gaussian to (value, coordinate) data. Parameters ---------- y : array_like Array giving the values of the function. x : ndarray, same shape as np.indices(y) (optional) An array giving the abcissas of y in the format of np.indices(). Must be sorted ascending (which is not checked) if guess is not given. Default: np.indices(y) guess : tuple, (width, center, height) Tuple giving an initial guess of the Gaussian parameters for the optimizer. If supplied, x and y can be any shape and need not be sorted. See gaussian() for meaning and format of this tuple. lsargs : dictionary Optional arguments to scipy.optimize.leastsq(). Interesting ones include maxfev, ftol, xtol, and gtol. Do not redefine full_output, as the code depends on the value it sets for this parameter. By default, maxfev is set to 2000 since the default in the minimizer is too low. minout : Boolean If true, append the minimizer's output tuple to the other outputs. Returns ------- width : ndarray, one element per dimension The fitted Gaussian widths in each dimension. center : ndarray, one element per dimension The fitted Gaussian center coordinate in each dimension. height : ndarray scalar The fitted height. err : ndarray, 2 * number-of-dims + 1 elements An array containing the concatenated uncertainties for width, center, and height, ordered as above. For example, 2D input gives np.array([widthyerr, widthxerr, centeryerr, centerxerr, heighterr]). lsout : tuple (Optional) Minimizer output, all in one tuple. Included only if minout=True. See scipy.optimize.leastsq() for documentation of its contents. Notes ----- If the input does not look anything like a Gaussian, the result might not even be the best fit to that. Method: First guess the parameters (if no guess is provided), then call a Levenberg-Marquardt optimizer to finish the job. Examples -------- >>> import matplotlib.pyplot as plt >>> import gaussian as g >>> # parameters for X >>> lx = -3. # low end of range >>> hx = 5. # high end of range >>> dx = 0.05 # step >>> # parameters of the noise >>> nc = 0.0 # noice center >>> ns = 1.0 # noise width >>> na = 0.2 # noise amplitude >>> # 1D Example >>> # parameters of the underlying Gaussian >>> wd = 1.1 # width >>> ct = 1.2 # center >>> ht = 2.2 # height >>> # x and y data to fit >>> x = np.arange(lx, hx + dx / 2., dx) >>> x += na * np.random.normal(nc, ns, x.size) >>> y = g.gaussian(x, wd, ct, ht) + na * np.random.normal(nc, ns, x.size) >>> s = x.argsort() # sort, in case noise violated order >>> xs = x[s] >>> ys = y[s] >>> # calculate guess and fit >>> (width, center, height) = g.gaussianguess(ys, xs) >>> (fw, fc, fh, err) = g.fitgaussian(ys, xs) >>> # plot results >>> plt.clf() >>> plt.plot(xs, ys) >>> plt.plot(xs, g.gaussian(xs, wd, ct, ht)) >>> plt.plot(xs, g.gaussian(xs, width, center, height)) >>> plt.plot(xs, g.gaussian(xs, fw, fc, fh)) >>> plt.title('Gaussian Data, Guess, and Fit') >>> plt.xlabel('Abcissa') >>> plt.ylabel('Ordinate') >>> # plot residuals >>> plt.clf() >>> plt.plot(xs, ys - g.gaussian(xs, fw, fc, fh)) >>> plt.title('Gaussian Fit Residuals') >>> plt.xlabel('Abcissa') >>> plt.ylabel('Ordinate') >>> # 2D Example >>> # parameters of the underlying Gaussian >>> wd = (1.1, 3.2) # width >>> ct = (1.2, 3.1) # center >>> ht = 2.2 # height >>> # x and y data to fit >>> nx = (hx - lx) / dx + 1 >>> x = np.indices((nx, nx)) * dx + lx >>> y = g.gaussian(x, wd, ct, ht) + na * np.random.normal(nc, ns, x.shape[1:]) >>> # calculate guess and fit >>> (width, center, height) = g.gaussianguess(y, x) >>> (fw, fc, fh, err) = g.fitgaussian(y, x) >>> # plot results >>> plt.clf() >>> plt.title('2D Gaussian Given') >>> plt.xlabel('X') >>> plt.ylabel('Y') >>> plt.imshow( g.gaussian(x, wd, ct, ht)) >>> plt.clf() >>> plt.title('2D Gaussian With Noise') >>> plt.xlabel('X') >>> plt.ylabel('Y') >>> plt.imshow(y) >>> plt.clf() >>> plt.title('2D Gaussian Guessed') >>> plt.xlabel('X') >>> plt.ylabel('Y') >>> plt.imshow( g.gaussian(x, width, center, height)) >>> plt.clf() >>> plt.title('2D Gaussian Fit') >>> plt.xlabel('X') >>> plt.ylabel('Y') >>> plt.imshow( g.gaussian(x, fw, fc, fh)) >>> plt.clf() >>> plt.title('2D Gaussian Fit Residuals') >>> plt.xlabel('X') >>> plt.ylabel('Y') >>> plt.imshow(y - g.gaussian(x, fw, fc, fh)) >>> # All cases benefit from... >>> # show difference between fit and underlying Gaussian >>> # Random data, your answers WILL VARY. >>> np.array(fw) - np.array(wd) array([-0.00015463, 0.01373218]) >>> np.array(fc) - np.array(ct) array([ 0.00061797, -0.00113882]) >>> np.array(fh) - np.array(ht) -0.0026334217737993271 Revisions --------- 2007-09-17 0.1 [email protected] Initial version 0.01, portions adapted from http://www.scipy.org/Cookbook/FittingData. 2007-11-13 0.2 [email protected] Made N-dimensional. 2008-12-02 0.3 [email protected] Included error calculation, and return Fixed a bug in which if the initial guess was None, and incorrect shape array was generated. This caused gaussian guess to fail. 2009-10-25 0.4 [email protected] Converted to standard doc header, fixed examples to return 4 parameters. 2009-11-14 0.5 [email protected] Fixed examples for N-dimensional gaussianguess(), fixed code spacing. 2010-12-15 0.6 [email protected] Tested for success in leastsq. 2011-10-11 0.7 [email protected] Fixed test for success, added argument passing and full return to/from minimizer. 2014-10-07 0.8 [email protected] Convert to Python 3, update examples. 2014-11-24 0.9 [email protected] Change 2x np.append into 1x np.hstack. 2016-10-25 0.11 Changed == to "is" and != to "is not" in None comparisons. 2017-10-10 0.12 Integer division of pdim to use as index in Python3. ''' if x is None: x = np.indices(y.shape) else: if (((x.ndim == 1) and (x.shape != y.shape)) or ((x.ndim > 1) and (x.shape[1:] != y.shape))): raise ValueError("x must give coordinates of points in y.") if guess is None: guess = gaussianguess(y, x) # "ravel" the guess gss = np.hstack((guess[0], guess[1], guess[2])) # fit residuals = lambda p: np.ravel(gaussian(x, param=p) - y) lsout = so.leastsq(residuals, gss, full_output=True, **lsargs) p, cov, info, mesg, success = lsout if success < 1 \ or success > 4: raise ValueError(mesg + " No convergence. Guess = " + str(guess) \ + "; try a different guess, maxfev, or tolerances.\n See scipy.optimize.leastsq() docs.") err = np.sqrt(np.diagonal(cov)) # unravel the result pdim = len(p) pdim = (pdim - 1) // 2 # integer division to use as an index width = p[:pdim] center = p[pdim:2 * pdim] height = p[-1] ret = (width, center, height, err) if minout: ret = (width, center, height, err, lsout) return ret
import scipy.optimize as opt def gauss(x, p): # p[0]==mean, p[1]==stdev return 1.0 / (p[1] * np.sqrt(2 * np.pi)) * np.exp(-(x - p[0])**2 / (2 * p[1]**2)) # Create some sample data known_param = np.array([2.0, .7]) xmin, xmax = -1.0, 5.0 N = 1000 X = np.linspace(xmin, xmax, N) Y = gauss(X, known_param) # Add some noise Y += .10 * np.random.random(N) # Renormalize to a proper PDF Y /= ((xmax - xmin) / N) * Y.sum() # Fit a guassian p0 = [0, 1] # Inital guess is a normal distribution errfunc = lambda p, x, y: gauss(x, p) - y # Distance to the target function p1, success = opt.leastsq(errfunc, p0[:], args=(X, Y)) fit_mu, fit_stdev = p1 FWHM = 2 * np.sqrt(2 * np.log(2)) * fit_stdev # Full width Half Max print("FWHM = ", FWHM)
def plotfunction(str): #val = '%.2f' % i[j] #print '%s' % val filename = "ave_%s.plot.err_trim" % i[j] x, y, err = np.loadtxt(fname='../%s.xvg' % filename, delimiter=' ', skiprows=4, usecols=(0, 1, 2), unpack=True) ## load data in for fitting xdata, ydata, yerr = np.loadtxt(fname='../%s.xvg' % filename, delimiter=' ', skiprows=4000, usecols=(0, 1, 2), unpack=True) ########## # Fitting the data -- Least Squares Method ########## # Power-law fitting is best done by first converting # to a linear equation and then fitting to a straight line. # # y = a * x^b # log(y) = log(a) + b*log(x) # # adapted from http://scipy-cookbook.readthedocs.io/items/FittingData.html powerlaw = lambda x, amp, index: amp * (x**index) #yerr = 0 #yerr = 0.01 * ydata logx = np.log10(xdata) logy = np.log10(ydata) logyerr = yerr / ydata #define our (line) fitting function #fitfunc = lambda p, x: p[0] + p[1] * x #errfunc = lambda p, x, y: (y - fitfunc(p, x)) #pinit = [1.0, -1.0] #out = optimize.leastsq(fitfunc, pinit, # args=(logx, logy), full_output=1) # define our (line) fitting function fitfunc = lambda p, x: p[0] + p[1] * x errfunc = lambda p, x, y, err: (y - fitfunc(p, x)) / err pinit = [1.0, -1.0] out = optimize.leastsq(errfunc, pinit, args=(logx, logy, logyerr), full_output=1) pfinal = out[0] covar = out[1] #print pfinal #print covar index = pfinal[1] amp = 10.0**pfinal[0] #print index #print amp indexErr = np.sqrt(covar[0][0]) #ampErr = np.sqrt( covar[1][1] ) * amp ########## # Plotting data ########## #plt.title('%s' % filename) plt.plot(x, y, color='%s' % plotStyle[j], marker='.', markersize=2) #plt.plot(x, y, color='%s' % plotStyle[j], marker='.', markersize=2) #plt.text(5, 6.5, 'a = %5.2f' % index) #plt.text(5, 4.5, 'k = %5.2f' % amp) #plt.errorbar(x, y, yerr=err, fmt='k.') plt.loglog(xdata, powerlaw(xdata, amp, index), 'r-', alpha=0) plt.xlabel('Time (ps)') plt.ylabel('MSD (nm)') plt.xlim(0, 50) plt.savefig('All.png')
# simplex, esow = Monitor(), Monitor() solver = fmin(len(point)) solver.SetInitialPoints(point) solver.SetEvaluationMonitor(esow) solver.SetGenerationMonitor(simplex) solver.Solve(cost_function, CRT()) sol = solver.Solution() print("\nsimplex solution: %s" % sol) # solcg = fmin_cg(cost_function, point) print("\nConjugate-Gradient (Polak Rubiere) : %s" % solcg) # if leastsq: sollsq = leastsq(vec_cost_function, point) sollsq = sollsq[0] print("\nLeast Squares (Levenberg Marquardt) : %s" % sollsq) # legend = ['Noisy data', 'Differential Evolution', 'Nelder Mead', 'Polak Ribiere'] plot_noisy_data() plot_sol(desol,'r-') plot_sol(sol,'k--') plot_sol(solcg,'b-.') if leastsq: plot_sol(sollsq,'g-.') legend += ['Levenberg Marquardt'] plt.legend(legend) plt.show() # end of file
def nls_fit_fwdki(design_matrix, design_matrix_dki, data, S0, params=None, Diso=3e-3, f_transform=True, mdreg=2.7e-3): """ Fit the water elimination DKI model using the non-linear least-squares. Parameters ---------- design_matrix : array (g, 22) Design matrix holding the covariants used to solve for the regression coefficients. data : ndarray ([X, Y, Z, ...], g) Data or response variables holding the data. Note that the last dimension should contain the data. It makes no copies of data. S0 : ndarray ([X, Y, Z]) A first guess of the non-diffusion signal S0. params : ndarray ([X, Y, Z, ...], 28), optional A first model parameters guess (3 eigenvalues, 3 coordinates of 3 eigenvalues, 15 elements of the kurtosis tensor and the volume fraction of the free water compartment). If the initial params are not given, for the diffusion and kurtosis tensor parameters, its initial guess is obtain from the standard DKI model, while for the free water fraction its value is estimated using the fwDTI model. Default: None Diso : float, optional Value of the free water isotropic diffusion. Default is set to 3e-3 $mm^{2}.s^{-1}$. Please ajust this value if you are assuming different units of diffusion. f_transform : bool, optional If true, the water volume fractions is converted during the convergence procedure to ft = arcsin(2*f - 1) + pi/2, insuring f estimates between 0 and 1. Default: True mdreg : float, optimal DTI's mean diffusivity regularization threshold. If standard DTI diffusion tensor's mean diffusivity is almost near the free water diffusion value, the diffusion signal is assumed to be only free water diffusion (i.e. volume fraction will be set to 1 and tissue's diffusion parameters are set to zero). Default md_reg is 2.7e-3 $mm^{2}.s^{-1}$ (corresponding to 90% of the free water diffusion value). Returns ------- fw_params : ndarray (x, y, z, 28) Matrix containing in the dimention the free water model parameters in the following order: 1) Three diffusion tensor's eigenvalues 2) Three lines of the eigenvector matrix each containing the first, second and third coordinates of the eigenvector 3) Fifteen elements of the kurtosis tensor 4) The volume fraction of the free water compartment S0 : ndarray (x, y, z) The models estimate of the non diffusion-weighted signal S0. """ # preparing data and initializing parameters data = np.asarray(data) data_flat = np.reshape(data, (-1, data.shape[-1])) S0out = S0.copy() S0out = S0out.ravel() # Computing WLS DTI solution for MD regularization dtiparams = dti.wls_fit_tensor(design_matrix, data_flat) md = dti.mean_diffusivity(dtiparams[..., :3]) cond = md > mdreg # removal condition data_cond = data_flat[~cond, :] # Initializing fw_params according to selected initial guess if np.any(params) is None: params_out = np.zeros((len(data_flat), 28)) dkiparams = dki.wls_fit_dki(design_matrix_dki, data_flat) fweparams, sd = fwdti.wls_fit_tensor(design_matrix, data_flat, S0=S0, Diso=Diso, mdreg=2.7e-3) params_out[:, 0:27] = dkiparams params_out[:, 27] = fweparams[:, 12] else: params_out = params.copy() params_out = np.reshape(params_out, (-1, params_out.shape[-1])) params_cond = params_out[~cond, :] S0_cond = S0out[~cond] for vox in range(data_cond.shape[0]): if np.all(data_cond[vox] == 0): raise ValueError("The data in this voxel contains only zeros") params = params_cond[vox] # converting evals and evecs to diffusion tensor elements evals = params[:3] evecs = params[3:12].reshape((3, 3)) dt = lower_triangular(vec_val_vect(evecs, evals)) kt = params[..., 12:27] s0 = S0_cond[vox] MD = evals.mean() # f transformation if requested if f_transform: f = np.arcsin(2 * params[27] - 1) + np.pi / 2 else: f = params[27] # Use the Levenberg-Marquardt algorithm wrapped in opt.leastsq start_params = np.concatenate((dt, kt * MD * MD, [np.log(s0), f]), axis=0) this_tensor, status = opt.leastsq(_nls_err_func, start_params, args=(design_matrix_dki, data_cond[vox], Diso, f_transform)) # Invert f transformation if this was requested if f_transform: this_tensor[22] = 0.5 * (1 + np.sin(this_tensor[22] - np.pi / 2)) # The parameters are the evals and the evecs: evals, evecs = decompose_tensor(from_lower_triangular(this_tensor[:6])) MD = evals.mean() params_cond[vox, :3] = evals params_cond[vox, 3:12] = evecs.ravel() params_cond[vox, 12:27] = this_tensor[6:21] / (MD**2) params_cond[vox, 27] = this_tensor[22] S0_cond[vox] = np.exp(-this_tensor[21]) params_out[~cond, :] = params_cond params_out[cond, 27] = 1 # Only free water params_out = np.reshape(params_out, (data.shape[:-1]) + (28, )) S0out[~cond] = S0_cond S0out[cond] = \ np.mean(data_flat[cond, :] / \ np.exp(np.dot(design_matrix[..., :6], np.array([Diso, 0, Diso, 0, 0, Diso]))), -1) # Only free water S0out = S0out.reshape(data.shape[:-1]) return params_out, S0out
def _clean(self, ar): # plot = self.configs.plot # if plot: # import matplotlib.pyplot as plt patient = ar.clone() patient.pscrunch() patient.remove_baseline() # Remove profile from dedispersed data patient.dedisperse() utils.print_info('Loading template', 2) data = patient.get_data().squeeze() if self.configs.template is None: # Sum over all axes except last, which is phase bins template = np.apply_over_axes(np.sum, data, tuple(range(data.ndim - 1))).squeeze() # smooth data template = savgol_filter(template, 5, 1) else: template_ar = psrchive.Archive_load(self.configs.template) template_ar.pscrunch() template_ar.remove_baseline() template_ar.dedisperse() if len(template_ar.get_frequencies()) > 1 and len( template_ar.get_frequencies()) < len( patient.get_frequencies()): utils.print_info( "Template channel number doesn't match data... f-scrunching!", 2) template_ar.fscrunch() template_data = template_ar.get_data().squeeze() template = np.apply_over_axes(np.sum, template_data, tuple(range(template_data.ndim - 1))).squeeze() # make sure template is 1D if len(np.shape(template)) > 1: # sum over frequencies too template_ar.fscrunch() utils.print_info( "2D template found. Assuming it has same frequency coverage and channels as data!", 2) template_phs = np.apply_over_axes( np.sum, template_data, tuple(range(template_data.ndim - 1))).squeeze() else: template_phs = template utils.print_info('Estimating template and profile phase offset', 2) if self.configs.template is None: phase_offset = 0 else: # Calculate phase offset of template in number of bins, using full obs # Get profile data of full obs profile = np.apply_over_axes(np.sum, data, tuple(range(data.ndim - 1))).squeeze() if np.shape(template_phs) != np.shape(profile): utils.print_info( 'Template and profile have different numbers of phase bins', 2) #err = (lambda (amp, phs, base): amp*clean_utils.fft_rotate(template_phs, phs) + base - profile) err = (lambda amp_phs: amp_phs[0] * clean_utils.fft_rotate( template_phs, amp_phs[1]) - profile) amp_guess = np.median(profile) / np.median(template_phs) phase_guess = -(np.argmax(profile) - np.argmax(template_phs)) amp_phs_guess = [amp_guess, phase_guess] #params, status = leastsq(err, [amp_guess, phase_guess, np.min(profile) - np.min(template_phs)]) params, status = leastsq(err, amp_phs_guess) phase_offset = params[1] utils.print_info( 'Template phase offset = {0}'.format(round(phase_offset, 3)), 2) utils.print_info('Removing profile from patient', 2) # if plot: # preop_patient = patient.clone() # preop_weights = preop_patient.get_weights() clean_utils.remove_profile_inplace(patient, template, phase_offset) utils.print_info('Accessing weights and applying to patient', 2) # re-set DM to 0 # patient.dededisperse() # Get weights weights = patient.get_weights() # Get data (select first polarization - recall we already P-scrunched) data = patient.get_data()[:, 0, :, :] data = clean_utils.apply_weights(data, weights) # if plot: # preop_data = preop_patient.get_data()[:,0,:,:] # preop_patient = [] # clear for the sake of memory # preop_data = clean_utils.apply_weights(preop_data, weights) # Mask profiles where weight is 0 mask_2d = np.bitwise_not(np.expand_dims(weights, 2).astype(bool)) mask_3d = mask_2d.repeat(ar.get_nbin(), axis=2) data = np.ma.masked_array(data, mask=mask_3d) # if plot: # preop_data = np.ma.masked_array(preop_data, mask=mask_3d) utils.print_info('Masking on-pulse region as determined from template', 2) # consider residual only in off-pulse region if len(np.shape(template)) > 1: # sum over frequencies utils.print_info( 'Estimating on-pulse region by f-scrunching 2D template', 2) template_ar.fscrunch() template_1D = np.apply_over_axes(np.sum, template_ar.get_data(), (0, 1)).squeeze() else: template_1D = template # Rotate template by apropriate amount template_rot = clean_utils.fft_rotate(template_1D, phase_offset).squeeze() # masked_template = np.ma.masked_greater(template_rot, np.min(template_rot) + 0.01*np.ptp(template_rot)) masked_template = np.ma.masked_greater(template_rot, np.median(template_rot)) masked_std = np.ma.std(masked_template) # use this std of masked data as cutoff masked_template = np.ma.masked_greater( template_rot, np.median(template_rot) + masked_std) # if plot: # plt.figure(figsize=(10, 5)) # plt.subplot(1, 2, 1) # plt.plot(np.apply_over_axes(np.sum, preop_data, tuple(range(data.ndim - 1))).squeeze(), alpha=1) # # Do fit again to scale template # subchan, err, params = clean_utils.remove_profile1d(np.apply_over_axes(np.sum, preop_data, (0, 1)).squeeze(), 0, 0, template_rot, 0, return_params=True) # # plt.plot(params[0]*template_rot + params[1], alpha=0.5) # # plt.plot(params[0]*masked_template + params[1], 'k') # plt.plot(params[0]*template_rot, alpha=0.5) # plt.plot(params[0]*masked_template, 'k') # plt.legend(('Pre-op data', 'Scaled and rotated template', 'Masked template')) # Loop through chans and subints to mask on-pulse phase bins for ii in range(0, np.shape(data)[0]): for jj in range(0, np.shape(data)[1]): data.mask[ii, jj, :] = masked_template.mask data = np.ma.masked_array(data, mask=data.mask) # if plot: # plt.subplot(1, 2, 2) # plt.plot(np.apply_over_axes(np.ma.sum, data, tuple(range(data.ndim - 1))).squeeze()) # plt.title("Residual data") # plt.savefig('data_and_template.png') utils.print_info( 'Calculating robust statistics to determine where RFI removal is required', 2) # RFI-ectomy must be recommended by average of tests # BWM: Ok, so this is where the magical stuff actually happens - need to know actually WHAT are the comprehensive stats # DJR: At this stage the stats are; (found to work well experimentally) # geometric mean, peak-to-peak, standard deviation, normaltest. # In original coast_guard they were; # mean, peak-to-peak, standard deviation, and max value of FFT avg_test_results = clean_utils.comprehensive_stats(data, axis=2, \ chanthresh=self.configs.chanthresh, \ subintthresh=self.configs.subintthresh, \ chan_order=self.configs.chan_order, \ chan_breakpoints=self.configs.chan_breakpoints, \ chan_numpieces=self.configs.chan_numpieces, \ subint_order=self.configs.subint_order, \ subint_breakpoints=self.configs.subint_breakpoints, \ subint_numpieces=self.configs.subint_numpieces, \ ) utils.print_info('Applying RFI masking weights to archive', 2) for (isub, ichan) in np.argwhere(avg_test_results >= 1): # Be sure to set weights on the original archive, and # not the clone we've been working with. integ = ar.get_Integration(int(isub)) integ.set_weight(int(ichan), 0.0) freq_fraczap = clean_utils.freq_fraczap(ar)
def residuals(self, data): """Determine residuals of data to model. For each point the shortest distance to the ellipse is returned. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- residuals : (N, ) array Residual for each data point. """ _check_data_dim(data, dim=2) xc, yc, a, b, theta = self.params ctheta = math.cos(theta) stheta = math.sin(theta) x = data[:, 0] y = data[:, 1] N = data.shape[0] def fun(t, xi, yi): ct = math.cos(t) st = math.sin(t) xt = xc + a * ctheta * ct - b * stheta * st yt = yc + a * stheta * ct + b * ctheta * st return (xi - xt)**2 + (yi - yt)**2 # def Dfun(t, xi, yi): # ct = math.cos(t) # st = math.sin(t) # xt = xc + a * ctheta * ct - b * stheta * st # yt = yc + a * stheta * ct + b * ctheta * st # dfx_t = - 2 * (xi - xt) * (- a * ctheta * st # - b * stheta * ct) # dfy_t = - 2 * (yi - yt) * (- a * stheta * st # + b * ctheta * ct) # return [dfx_t + dfy_t] residuals = np.empty((N, ), dtype=np.double) # initial guess for parameter t of closest point on ellipse t0 = np.arctan2(y - yc, x - xc) - theta # determine shortest distance to ellipse for each point for i in range(N): xi = x[i] yi = y[i] # faster without Dfun, because of the python overhead t, _ = optimize.leastsq(fun, t0[i], args=(xi, yi)) residuals[i] = np.sqrt(fun(t, xi, yi)) return residuals
def residuals(p, y, x): A,k,theta = p err = y-func(x,A,k,theta) return err def peval(x, p): A,k,theta = p return func(x,A,k,theta) p0 = [np.max(y_meas), np.pi/11, np.pi/3] print 'Guess:\t',np.array(p0) # [ 8. 43.4783 1.0472] plsq = leastsq(residuals, p0, args=(y_meas, x)) print 'Found:\t',plsq[0] # [ 10.9437 33.3605 0.5834] print 'Theor:\t',np.array([A, k, theta]) # [ 10. 33.3333 0.5236] print 'RMSD :\t',rmsd(plsq[0], np.array([A, k, theta])) plt.plot(x,peval(x,plsq[0]), label='Fit' ) plt.plot(x,y_meas,'x', label='Measured') plt.plot(x,y_true , label='Theoretical') plt.title('Least-squares fit to noisy data') plt.legend() plt.show()
def fit_cos_fixed_phase_offset(xdata,ydata,p0): plsq,cov,info,mesg,success = leastsq(_residuals_cos_fixed_phase_offset, p0, args=(xdata,ydata), full_output = 1) plsq=[plsq] dof = len(xdata) - 1 errors = estimate_errors(plsq, info, cov, dof) return plsq, errors
def bestfit_circle_numpy(points): """Fit a circle through a set of points. Parameters ---------- points : list XYZ coordinates of the points. Returns ------- tuple XYZ coordinates of the center of the circle, the normal vector of the local frame, and the radius of the circle. Notes ----- The point of this function is to find the bestfit frame through the given points and transform the points to make the problem 2D. Once in 2D, the problem simplifies to finding the center point that minimises the difference between the resulting circles for all given points, i.e. minimise in the least squares sense the deviation between the individual radii and the average radius. For more information see [1]_. References ---------- .. [1] Scipy. *Least squares circle*. Available at: http://scipy-cookbook.readthedocs.io/items/Least_Squares_Circle.html. Examples -------- >>> """ o, uvw, _ = pca_numpy(points) frame = [o, uvw[1], uvw[2]] rst = world_to_local_coordinates_numpy(frame, points) x = rst[:, 0] y = rst[:, 1] def dist(xc, yc): # compute the radius of the circle through each of the given points # for the current centre point return sqrt((x - xc) ** 2 + (y - yc) ** 2) def f(c): # compute the deviation of the radius of each sample point # from the average radius # => minimize this deviation Ri = dist(*c) return Ri - Ri.mean() xm = mean(x) ym = mean(y) c0 = xm, ym c, error = leastsq(f, c0) # compute the radius of the circle through each sample point for the # computed center point. Ri = dist(*c) # compute the radius of the bestfit circle as the average of the individual # radii. R = Ri.mean() # residu = sum((Ri - R) ** 2) # print(residu) # convert the location of the center point back to global coordinates. xyz = local_to_world_coordinates_numpy(frame, [[c[0], c[1], 0.0]])[0] return xyz, uvw[2], R
def fit_integer_phase(ndata, ydata, p0): ''' p = [phase, A, y0] ''' plsq,cov,info,mesg,success = leastsq(_residuals_integer_pahse, p0, args=(ndata,ydata), full_output = 1)
def estimate(self, data): """Estimate circle model from data using total least squares. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- success : bool True, if model estimation succeeds. """ _check_data_dim(data, dim=2) x = data[:, 0] y = data[:, 1] N = data.shape[0] # pre-allocate jacobian for all iterations A = np.zeros((N + 5, 2 * N), dtype=np.double) # same for all iterations: xc, yc A[0, :N] = -1 A[1, N:] = -1 diag_idxs = np.diag_indices(N) def fun(params): xyt = self.predict_xy(params[5:], params[:5]) fx = x - xyt[:, 0] fy = y - xyt[:, 1] return np.append(fx, fy) def Dfun(params): xc, yc, a, b, theta = params[:5] t = params[5:] ct = np.cos(t) st = np.sin(t) ctheta = math.cos(theta) stheta = math.sin(theta) # derivatives for fx, fy in the following order: # xc, yc, a, b, theta, t_i # fx A[2, :N] = -ctheta * ct A[3, :N] = stheta * st A[4, :N] = a * stheta * ct + b * ctheta * st A[5:, :N][diag_idxs] = a * ctheta * st + b * stheta * ct # fy A[2, N:] = -stheta * ct A[3, N:] = -ctheta * st A[4, N:] = -a * ctheta * ct + b * stheta * st A[5:, N:][diag_idxs] = a * stheta * st - b * ctheta * ct return A # initial guess of parameters using a circle model params0 = np.empty((N + 5, ), dtype=np.double) xc0 = x.mean() yc0 = y.mean() r0 = np.sqrt((x - xc0)**2 + (y - yc0)**2).mean() params0[:5] = (xc0, yc0, r0, 0, 0) params0[5:] = np.arctan2(y - yc0, x - xc0) params, _ = optimize.leastsq(fun, params0, Dfun=Dfun, col_deriv=True) self.params = params[:5] return True