def exponential_fit(ac, use_function='single'): """Perform a single- or double- exponential fit on an autocorrelation curve. RETURNS yFit - the y-values of the fit curve.""" nsteps = ac.shape[0] if use_function == 'single': v0 = [0.0, 1.0 , 4000.] # Initial guess [a0, a1, tau1] for a0 + a1*exp(-(x/tau1)) popt, pcov = curve_fit(single_exp_decay, np.arange(nsteps), ac, p0=v0, maxfev=10000) # ignore last bin, which has 0 counts yFit_data = single_exp_decay(np.arange(nsteps), popt[0], popt[1], popt[2]) # print 'best-fit a0 = ', popt[0], '+/-', pcov[0][0] # print 'best-fit a1 = ', popt[1], '+/-', pcov[1][1] print 'best-fit tau1 = ', popt[2], '+/-', pcov[2][2] else: v0 = [0.0, 0.9, 0.1, 4000., 200.0] # Initial guess [a0, a1,a2, tau1, tau2] for a0 + a1*exp(-(x/tau1)) + a2*exp(-(x/tau2)) popt, pcov = curve_fit(double_exp_decay, np.arange(nsteps), ac, p0=v0, maxfev=10000) # ignore last bin, which has 0 counts yFit_data = double_exp_decay(np.arange(nsteps), popt[0], popt[1], popt[2], popt[3], popt[4]) # print 'best-fit a0 = ', popt[0], '+/-', pcov[0][0] #print 'best-fit a1 = ', popt[1], '+/-', pcov[1][1] #print 'best-fit a2 = ', popt[2], '+/-', pcov[2][2] print 'best-fit tau1 = ', popt[3], '+/-', pcov[3][3] print 'best-fit tau2 = ', popt[4], '+/-', pcov[4][4] return yFit_data
def waterbulk(input, zcoord, func): x = input[0] densmean = np.zeros(200) i = 0 start = 0 for slice in range(1,200): ymean = input[slice] At = guess(ymean) popt, pcov = curve_fit(func, x, ymean,[At, 2, 1], maxfev=10000) k = func(0,*popt) densmean[slice]=k if k > 800: start = slice - i i = i + 1 end = start + i densmean2 = np.zeros(i + 1) i2 = 0 for slice2 in range(0,200): ymean = input[slice2] At = guess(ymean) popt, pcov = curve_fit(func, x, ymean,[At, 2, 1], maxfev=10000) k = func(0,*popt) if k > 800: densmean2[i2] = k i2 = i2 + 1 return np.median(densmean2)
def get_data(local_df,date_list): for i in date_list: # Slice data from the complete dataframe sub_df=local_df.ix[i-dt.timedelta(days=avg_window_noct/2)+dt.timedelta(hours=t_del): i+dt.timedelta(days=avg_window_noct/2)-dt.timedelta(hours=t_del)].dropna(axis=0,how='any') # If either too few data or temperature range is less than 5C, abort optimisation if len(sub_df) >= min_records and sub_df[tempName].max() - sub_df[tempName].min() >= temp_spread: global Eo Eo=params_df['Eo'].ix[i] # Try optimisation - if causes error return nan array if nocturnal_fit==True: try: params_df['rb_noct'][i]=curve_fit(TRF_rb,sub_df[tempName],sub_df[CfluxName],p0=1)[0] except RuntimeError: params_df['rb_noct'][i]=np.nan else: try: a=curve_fit(LRF,sub_df[[radName,tempName,VPDName]],sub_df[CfluxName],p0=[-0.1,-10,1,1])[0] except RuntimeError: a=[np.nan,np.nan,np.nan,np.nan] params_df['alpha'][i]=a[0] params_df['Aopt'][i]=a[1] params_df['k'][i]=a[2] params_df['rb_day'][i]=a[3]
def fit_multipeak(idata, npeak = 1, pos = None, wid = 3., ptype = 'Gaussian'): if pos is None: pos = find_peaks(idata, npeak) if len(pos) < npeak: raise ValueError('Must have a position estimate for each peak') else: npeak = [len(pos[x]) for x in pos] x_data = np.array(range(len(idata))) f = interp1d(x_data, idata, kind='cubic') amps = f(pos['pos']), f(pos['neg']) med = np.median(idata) #split into positive and negative so that we can differentiate between #the two original images pmodel = multi_peak_model(ptype, len(amps[0])) pinit = [np.array([a, pos['pos'][i], wid]) for i, a in enumerate(amps[0])] pdata = np.clip(idata, a_min=med, a_max=np.nanmax(idata)) p_fit, p_tmp = curve_fit(pmodel, x_data, pdata, pinit) nmodel = multi_peak_model(ptype, len(amps[1])) ninit = [np.array([a, pos['neg'][i], wid]) for i, a in enumerate(amps[1])] ndata = np.clip(idata, a_max=med, a_min=np.nanmin(idata)) n_fit, n_tmp = curve_fit(nmodel, x_data, ndata, ninit) return x_data, build_composite(p_fit, ptype), build_composite(n_fit, ptype)
def add_fits_to_plot(ax, beta_rms,mdots): beta_cont= np.logspace(-3,1,num=1000) p0 = [19.8,1.] opt, pcov = curve_fit(lee_parallel,beta_rms,mdots,p0=p0) lab=r'$\dot{M}_{\parallel}: \beta_{ch}= %.1f, n = %.1f$' % (opt[0],opt[1]) #ax.plot(beta_cont,np.exp(lee_parallel(beta_cont,opt[0],opt[1])),'b-',lw=2,label=lab) # p0 = [19.8] opt, pcov = curve_fit(lee_parallel_neq100,beta_rms,mdots,p0=p0) lab=r'$\dot{M}_{\parallel}: \beta_{ch}= %.1f, n \equiv %.1f$' % (opt[0],100) #ax.plot(beta_cont,np.exp(lee_parallel_neq100(beta_cont,opt[0])),'r-',lw=2,label=lab) # p0 = [19.8] opt, pcov = curve_fit(lee_parallel_neq8,beta_rms,mdots,p0=p0) #lab=r'$\dot{M}_{\parallel}: \beta_{ch}= %.2f, n \equiv %d$' % (opt[0],8) lab=r'$\dot{M}_{\rm{Magn.}}: \beta_{ch}= %.1f, n \equiv %d$' % (opt[0],8) ax.plot(beta_cont,np.exp(lee_parallel_neq8(beta_cont,opt[0])),'b-',lw=4,label=lab) # lab=r'$\dot{M}_{\parallel}: \beta_{ch}=19.8, n=1$ (Lee 2014)' #ax.plot(beta_cont,np.exp(lee_parallel(beta_cont,19.8,1.)),'g-',lw=2,label=lab) #p0 = [19.8] #opt, pcov = curve_fit(lee_parallel_neq100,beta_rms,mu,p0=p0) #lab=r'$\beta_{ch}= %.1f$' % (opt[0]) #ax[0].plot(beta_cont,lee_parallel_neq100(beta_cont,opt[0]),'b-',lw=2,label=lab) # p0 = [1,19.8, # p0 = [1,19.8,1] # for i in range(3): # fit = leastsq(residuals_par, p0, args=(log_mean, log_beta)) # p0=lsq_mean[0] # plt.plot(log_beta, lee_parallel(log_beta,lsq_mean[0][0],lsq_mean[0][1],lsq_mean[0][2]),c='b',ls='-',label=r'$\parallel$ mean' p0 = [11.1] opt, pcov = curve_fit(magnetic_bh_neq8,beta_rms,mdots,p0=p0) lab=r'$\dot{M}_{\rm{fit,bh}}: \beta_{ch}= %.1f, n= 8' % (opt[0]) ax.plot(beta_cont,np.exp(magnetic_bh_neq8(beta_cont,opt[0])),'r-',lw=4,label=lab)
def fit_m2(recondata, pguess, n, s, bounds=None): """ Fits the lunar equation based on lunar local time for each longitude to the reconstructed data in order to extract its amplitude and phase for comparison to the originals. :param recondata: Reconstructed lunar tide data binned by LLT, format [[ llt, longitude, tide]_0 ...[llt, longitude, tide]_n] :param pguess: Initial guess for parameters in format [amplitude, phase, background] :param bounds: Bounds for amplitude in format [[low A, low φ], [high A, high φ]] :param s: Spatial frequency of the tidal wave. :param n: Temporal frequency of the tidal wave. 2 for semidiurnal. :return: list containing the fit values for amplitude, phase and offset """ from scipy.optimize import curve_fit # Function that gets fit - nested to allow additional arguments def fit_lunar(n, s, L): def real_fitter(llt, A, P, C): return A * np.cos((2*pi*n / 24) * llt + (s - n)*L - P) + C return real_fitter if bounds is None: popt, pcov = curve_fit(fit_lunar(n, s, recondata[:, 1]), recondata[:, 0], recondata[:, 2], pguess) else: popt, pcov = curve_fit(fit_lunar(n, s, recondata[:, 1]), recondata[:, 0], recondata[:, 2], pguess, bounds=bounds) return [popt[0], popt[1], popt[2]]
def fullPeriodFit2plot(trdata1,trdata2,resids=False,planets=3): """If the option 'resids' is specified, plot the redisuals of the model fitting procedure. Otherwise show the TTVs plus the best-fit sinusoidal model""" n,t = trdata1.T[:2] n1,t1 = trdata2.T[:2] per0,per10 = map( lambda x: linearfit(x[0],x[1])[1], [[n,t],[n1,t1]] ) mdl = lambda x,p,t0,a,b,w: x * p + t0 + a * sin(w * p * x) + b * cos(w * p * x) j =2 +argmin([abs((j-1)*per10 / ( j*per0 ) - 1.) for j in range(2,5)]) w0 = 2. * pi * ( j / per10 - (j-1) / per0 ) popt, pcov = curve_fit(mdl, n, t, p0=[per0,t[0], 0.05, 0.05, w0 ] ) popt1, pcov1 = curve_fit(mdl, n1, t1, p0=[per10,t1[0], 0.05, 0.05, w0 ] ) if resids: errs,errs1 = trdata1[:,2],trdata2[:,2] if planets==1: plt.errorbar(t,t - mdl(n,popt[0],popt[1],popt[2],popt[3],popt[4]),yerr=errs,fmt='ks') elif planets==2: plt.errorbar(t1,t1 - mdl(n1,popt1[0],popt1[1],popt1[2],popt1[3],popt1[4]) ,yerr = errs1,fmt='rs') else: plt.errorbar(t,t - mdl(n,popt[0],popt[1],popt[2],popt[3],popt[4]),yerr=errs,fmt='ks') plt.errorbar(t1,t1 - mdl(n1,popt1[0],popt1[1],popt1[2],popt1[3],popt1[4]) ,yerr = errs1,fmt='rs') else: plot(n,mdl(n,popt[0],popt[1],popt[2],popt[3],popt[4])- popt[0]*n -popt[1] ) plot(n,t - popt[0]*n - popt[1] ) plot(n1,mdl(n1,popt1[0],popt1[1],popt1[2],popt1[3],popt1[4])- popt1[0]*n1 -popt1[1] ) plot(n1,t1 - popt1[0]*n1 - popt1[1] ) plt.show()
def myfit(x, y, betagamma, qL, orientation, T, yerr=None, krange=[]): if len(krange) != 0: # trim to given range booleanrange = [(x >= krange[0]) & (x <= krange[1])] x = x[booleanrange] y = y[booleanrange] if yerr is None: popt, pcov = curve_fit(fun, x, y, sigma=None) else: if len(krange) != 0: yerr = yerr[booleanrange] popt, pcov = curve_fit(fun, x, y, sigma=yerr, absolute_sigma=True) x = linspace(x[0], x[-1], 1e3) fit = fun(x, *popt) perr = sqrt(diag(pcov)) A = array([popt[0], perr[0]])/qL**2 B = array([popt[1], perr[1]])/qL*orientation C = array([popt[2], perr[2]]) eps, bet, alp, gam = twissfromparabola(A, B, C, T) epsn = betagamma*eps*1e6 eps *= 1e9 string = (r'$\beta=%.2f \pm %.2f$''\n' r'$\alpha=%.2f \pm %.2f$''\n' r'$\gamma=%.2f \pm %.2f$''\n' r'$\epsilon=(%.2f \pm %.2f)\pi\, nm\, rad$''\n' r'$\epsilon^*=(%.2f \pm %.2f)\pi\, \mu m\, rad$' % (bet[0], bet[1], alp[0], alp[1], gam[0], gam[1], eps[0], eps[1], epsn[0], epsn[1])) return x, fit, string
def fit_poly(x1, y1, xref, yref, num_free_param , p0x = None, p0y=None, minim=True, weightx=None, weighty =None, leg=False): ''' Assumes input is 2 matched starlists (x1, y1, x2, y2) free_param is number of free parameters to be used in the fit returns coefficients for best fit polynomial in both x and y ''' if p0x ==None: p0x = np.zeros(num_free_param) if p0y == None: p0y = np.zeros(num_free_param) if not minim: print 'weight of first point ',weightx[0], weighty[0] c_x, cov_x = curve_fit(poly, np.array([x1,y1]), xref, p0=p0x, sigma=weightx, absolute_sigma=True) print 'weight of first point ', weightx[0], weighty[0] c_y, cov_y = curve_fit(poly, np.array([x1,y1]), yref, p0=p0y, sigma=weighty, absolute_sigma=True) else: for i in range(len(p0x)): p0x[i] = p0x[i]# + i * .01 p0y[i] = p0y[i]# + i * .01 resx = minimize(poly_min,p0x, args=(x1,y1, xref, weightx, leg), method='CG') resy = minimize(poly_min,p0y, args=(x1,y1, yref, weighty, leg), method='CG') c_x = resx.x c_y = resy.x print c_y, c_x return c_x, c_y
def fit(self, xvals, yvals, evals=None, guess=(), handle_nans=True, **kwargs): """ Use xvals and yvals +/- evals to fit params with initial values p0. evals == None means don't use errorbars. guess == () means guess all 1.0 for the parameters (usually bad!) kwargs passed to curve_fit() handle_nans automatically drops tuples that have nan in any of xvals, yvals, or evals. """ if handle_nans: drop = np.isnan(xvals) drop = drop | np.isnan(yvals) if evals is not None: drop = drop | np.isnan(evals) xvals = np.array(xvals)[~drop] yvals = np.array(yvals)[~drop] if evals is not None: evals = np.array(evals)[~drop] if guess == (): guess = self._set_default_parms(xvals, yvals, evals) if (evals is None) or (np.isnan(evals).any()): fit = curve_fit(self.form, xvals, yvals, p0=guess, **kwargs) else: fit = curve_fit(self.form, xvals, yvals, sigma=evals, absolute_sigma=True, p0=guess, **kwargs) self.parm = np.array(guess) self.perr = np.array(guess) for pi, p in enumerate(guess): self.parm[pi] = fit[0][pi] self.perr[pi] = fit[1][pi][pi] ** 0.5 self.cov = fit[1] if len(self.parm) == len(self.pnms): self.pmap = dict(zip(self.pnms, self.parm)) self.emap = dict(zip(self.pnms, self.perr))
def threeGaussFit(TR): print len(TR.peak) if len(TR.peak)>0: if len(TR.peak)==1: sig=[TR.radius[0]] popt,pcov=curve_fit(oneGauss2,TR.x,TR.n,p0=[TR.peak[0],TR.amp[0],sig[0]]) TR.popt.append(popt[0]) TR.popt.append(popt[1]) TR.popt.append(popt[2]) TR.n=TR.n-nGauss(TR.x,popt[0],popt[1],popt[2]) elif len(TR.peak)==2: sig=[TR.radius[0],TR.radius[1]] popt,pcov=curve_fit(nGauss,TR.x,TR.n,p0=[TR.peak[0],TR.amp[0],sig[0],TR.peak[1],TR.amp[1],sig[1]]) for i in range(6): TR.popt.append(popt[i]) TR.n=TR.n-nGauss(TR.x,popt[0],popt[1],popt[2],popt[3],popt[4],popt[5]) else: sig=[TR.radius[0],TR.radius[1],TR.radius[2]] popt,pcov=curve_fit(nGauss,TR.x,TR.n,p0=[TR.peak[0],TR.amp[0],sig[0],TR.peak[1],TR.amp[1],sig[1],TR.peak[2],TR.amp[2],sig[2]]) for i in range(9): TR.popt.append(popt[i]) pb.plot(TR.x,nGauss(TR.x,popt[0],popt[1],popt[2],popt[3],popt[4],popt[5],popt[6],popt[7],popt[8]),color=col4,linewidth=1) pb.show() TR.n=TR.n-nGauss(TR.x,popt[0],popt[1],popt[2],popt[3],popt[4],popt[5],popt[6],popt[7],popt[8]) TR.sens=0.02*max(TR.y)
def HistFit( XInt ): # Calculate histogram hist, bin_edges = numpy.histogram(XInt, bins = 100, density=False) numpy.array(hist) datay = hist global bin_centers bin_centers = (bin_edges[:-1] + bin_edges[1:])/2 datax = bin_centers # define your function: def f(x, height, mean, sd): return height*numpy.exp(-(x-mean)**2/(2.*sd**2)) global mean, sd, CV mean = numpy.mean(XInt, axis=0) sd = numpy.std(XInt, axis=0) CV = sd/mean print mean, sd, CV height = 40000 p_init = numpy.array([height, mean, sd]) # fit! (given that data is an array with the data to fit) coeff, var_matrix = optimize.curve_fit(f, bin_centers, hist, p_init ) print optimize.curve_fit(f, bin_centers, hist, p_init ) print "this is the fit" print coeff mean = coeff[1] sd = coeff[2] print mean, CV hist_fit = f(bin_centers, *coeff) return hist_fit
def main(angles_org, firing_rates_org, initial_est, fig_title=''): # Plot the original data plt.figure() plt.title('Rotation Tuning ' + fig_title) plt.xlabel('Angle(Deg)') plt.ylabel('Normalized Firing Rate') plt.scatter(angles_org, firing_rates_org, label='Original Data') angles_arr = np.arange(-180, 180, step=1) # ------------------------------------------------------------------------------------------- # Single Gaussian Curve Fit # ------------------------------------------------------------------------------------------- params_fit, params_cov_mat = curve_fit( single_gaussian, angles_org, firing_rates_org, p0=initial_est[0, :]) # Standard deviation of fit parameters: # REF: (1) http://stackoverflow.com/questions/14581358/getting-standard-errors-on-fitted- # parameters-using-the-optimize-leastsq-method-i # (2) http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html params_err_std_dev = np.sqrt(np.diag(params_cov_mat)) plt.plot( angles_arr, single_gaussian(angles_arr, params_fit[0], params_fit[1], params_fit[2]), label=r'$1\ Gaussian:\ \mu_1=%0.2f,\ \sigma_1=%0.2f,\ Amp_1=%0.2f$' % (params_fit[0], params_fit[1], params_fit[2])) print ("1 Gaussian Fit - standard deviation of errors in parameters:" + "\n\tmu_1=%0.4f, sigma_1=%0.4f, Amp_1=%0.4f" % (params_err_std_dev[0], params_err_std_dev[1], params_err_std_dev[2])) # ------------------------------------------------------------------------------------------- # Mirror Symmetric Fit # ------------------------------------------------------------------------------------------- params_fit, params_cov_mat = curve_fit( pseudo_symmetric_gaussian, angles_org, firing_rates_org, p0=initial_est[0, :]) # Standard deviation of fit parameters: # REF: (1) http://stackoverflow.com/questions/14581358/getting-standard-errors-on-fitted- # parameters-using-the-optimize-leastsq-method-i # (2) http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html params_err_std_dev = np.sqrt(np.diag(params_cov_mat)) plt.plot( angles_arr, pseudo_symmetric_gaussian(angles_arr, params_fit[0], params_fit[1], params_fit[2]), label=r'$ Pseudo Sym Gaussian:\ \mu_1=%0.2f,\ \sigma_1=%0.2f,\ Amp_1=%0.2f$' % (params_fit[0], params_fit[1], params_fit[2])) print ("Pseudo Sym - standard deviation of errors in parameters:" + "\n\tmu_1=%0.4f, sigma_1=%0.4f, Amp_1=%0.4f" % (params_err_std_dev[0], params_err_std_dev[1], params_err_std_dev[2]))
def double_diode_fit_plot(df, parameters=False): fig, ax = plt.subplots() if isinstance(df,pd.DataFrame): for index, row in df.iterrows(): x = np.linspace(0.4,1,num=61) popt, pcov = curve_fit(double_diode_model,x,row.current_density[140:201],p0=(1e-10,1e-12)) curve_y = double_diode_model(x, popt[0],popt[1]) ax.plot(df.voltage, df.current_density) j01_string = "{0:.2e}".format(popt[0]) j02_string = "{0:.2e}".format(popt[1]) label = "$J_{01} = $" + j01_string + " $A \ cm^{-2}$" +"\n"+ "$J_{02} = $" +j02_string+ " $A \ cm^{-2}$" ax.plot(x, curve_y, '--', label = label) ax.legend() ax.set_xlabel("Voltage (V)") ax.set_ylabel("Current Density ($A \ cm^{-2}$)") if parameters: return fig, ax, J02_perimeter, J02_bulk, S0LS else: return fig, ax else: x = np.linspace(0.4,1,num=61) popt, pcov = curve_fit(double_diode_model,x,df.current_density[140:201],p0=(1e-10,1e-12)) curve_y = double_diode_model(x, popt[0],popt[1]) ax.plot(df.voltage[140:201], df.current_density[140:201]) j01_string = "{0:.2e}".format(popt[0]) j02_string = "{0:.2e}".format(popt[1]) label = "$J_{01} = $" + j01_string + " $A \ cm^{-2}$" +"\n"+ "$J_{02} = $" +j02_string+ " $A \ cm^{-2}$" ax.plot(x, curve_y, '--', label = label) ax.legend() ax.set_xlabel("Voltage (V)") ax.set_ylabel("Current Density ($A \ cm^{-2}$)") if parameters: return fig, ax, J02_perimeter, J02_bulk, S0LS else: return fig, ax
def main(): # calculate least squares beta coefficient using ls() beta_old = ls(variables['body'], variables['brain']) # calculate least squares beta coefficient using curve_fit() # reshape to go from (65, 1) to (65,) beta_new, vcov = curve_fit(linear, abrain, abody) print('Week 5 model: bo = %.4f * br + %.4f' % (beta_old[1][0], beta_old[0][0])) print('SciPy model: bo = %.4f * br + %.4f\n' % (beta_new[0], beta_new[1])) imports = 'from __main__ import curve_fit, linear, abrain, abody, ' + \ 'brain, body, ls, gaussian' times = 1000 scipy_implementation = timeit('curve_fit(linear, abrain, abody)', setup=imports, number=times) my_implementation = timeit('ls(body, brain)', setup=imports, number=times) gaussian_implementation = timeit('curve_fit(gaussian, abrain, abody)', setup=imports, number=times) for result in ('my_implementation', 'scipy_implementation', 'gaussian_implementation'): print('Avg execution time for %s (%i reps):\n%s' % (result, times, eval(result))) print('\nGuassian:\nscaling var = %.4f\nmu = %.4f\nsigma = %.4f' % tuple(curve_fit(gaussian, abrain, abody)[0]))
def plot_p_output(n): Ts,rhos,f1,f2,vdh = np.loadtxt(OUTNAME,unpack=True) plot_mrho = [] plot_mhoef = [] plot_mcalc = [] nmostafa = 400 sub_plot = 221 #fn = lambda xs:(lambda a,b,c:[a*xs[i]**2+b*xs[i]+c for i in xrange(len(xs))]) #quad = fn(rhos) quad = lambda a,b,c:[(rhos[i]**2)*(3*a*rhos[i]**2+2*b*rhos[i]+c)\ for i in xrange(len(rhos))] for i in xrange(0,len(rhos),n): s = slice(i,i+n) mslice = slice((i/n)*nmostafa,((i/n)+1)*nmostafa) plt.subplot(sub_plot) popt1,_ = curve_fit(cubic,rhos[s],f1[s],p0=[1,1,1,1]) popt2,_ = curve_fit(cubic,rhos[s],f2[s],p0=[1,1,1,1]) poptvdh,_ = curve_fit(cubic,rhos[s],Ts[i]*vdh[s],p0=[1,1,1,1]) p1, = plt.plot(rhos[s],quad(popt1[0],popt1[1],popt1[2])[s],\ marker = 'o', linewidth = 3) p2, = plt.plot(rhos[s],quad(popt2[0],popt2[1],popt2[2])[s],\ marker = '>', linewidth = 3, linestyle = '-.') p3, = plt.plot(rhos[s],quad(poptvdh[0],poptvdh[1],poptvdh[2])[s],\ marker = 'd', linewidth = 3, linestyle = ':') plt.xlabel('$\\rho$',fontsize = 20) plt.ylabel('P',fontsize = 15) plt.title('P vs $\\rho$ for T = '+str(Ts[i])) plt.legend([p1,p2,p3],['$1^{st}$ order','$2^{nd}$ order','Van der Hoef'],\ loc = 2) sub_plot += 1 plt.show() return
def plot_subline(n): Ts,rhos,f1,f2,fhoef = np.loadtxt(OUTNAME,unpack=True) plot_mrho = [] plot_mhoef = [] plot_mcalc = [] subd1 = [] subd2 = [] tpts = [] quad = lambda a,b,c:[(rhos[i]**2)*(3*a*rhos[i]**2+2*b*rhos[i]+c)\ for i in xrange(len(rhos))] quad_psolve = lambda a,b,c: (-b+np.sqrt(b*b-4*a*c))/(2*a) for i in xrange(0,len(rhos),n): s = slice(i,i+n) popt1,_ = curve_fit(cubic,rhos[s],f1[s],p0=[1,1,1,1]) popt2,_ = curve_fit(cubic,rhos[s],f2[s],p0=[1,1,1,1]) subd1 += [quad_psolve(popt1[0]*rhos[i]**2*3,popt1[1]*rhos[i]**2*2,\ popt1[2]*rhos[i]**2)] subd2 += [quad_psolve(popt2[0]*rhos[i]**2*3,popt2[1]*rhos[i]**2*2,\ popt2[2]*rhos[i]**2)] tpts += [Ts[i]] print tpts[-1],'\t',subd1[-1],'\t',subd2[-1] p1, = plt.plot(tpts,subd1,linewidth=3,marker='o') p2, = plt.plot(tpts,subd2,linewidth=3,linestyle='-.',marker='>') plt.xlabel('$T(K)$',fontsize=20) plt.ylabel('$\\rho(g/cm^3)$',fontsize=20) plt.title("Sublimation Density vs. Temperature") plt.legend([p1,p2],['$1^{st}$ order','$2^{nd}$ order'],loc=1) plt.show() return
def fit_func(func, x, y, yerr, xlong,ylong): start = time.time() p, cov = curve_fit(func, x, y, p0 = initial_guess(func,x,y), sigma = yerr, maxfev = 1000000) # print(p) if func == func_power: pi = p p, cov = curve_fit(func, x, y, p0 = initial_guess(func, x+p[2], y), sigma = yerr, maxfev = 1000000) while (np.any((pi/p-1)>0.001)): pi=p p, cov = curve_fit(func, x, y, p0 = initial_guess(func, x+p[2], y), sigma = yerr, maxfev = 1000000) perr = np.sqrt(np.diag(cov)) chi2red, pval = calculate_stats(x, y, yerr, p, perr, func) yfit = func(xlong,*p) resid = ylong-yfit p = unumpy.uarray(p,perr) extrapolate_val = func_err_prop(func,extrapolate_times,p) print(extrapolate_val) end = time.time() elapsed = end-start return (p, yfit, resid, extrapolate_val, chi2red, pval, elapsed)
def shift(ep): ids,x1,y1,mk,mj,x2,y2 = np.genfromtxt(ep,unpack=True) local_mask = np.in1d(ids,bid) lid,lx1,ly1,lx2,ly2 = np.transpose([ids,x1,y1,x2,y2])[local_mask].T loc_xy = np.transpose([lx2,ly2]) nbrs = NN(n_neighbors=vecinos, algorithm='auto').fit(loc_xy) coo_xy = np.transpose([x2,y2]) dist, idx = nbrs.kneighbors(coo_xy) idx = idx[:,1:] dist = dist[:,1:] ctx = np.zeros(x1.size) cty = np.zeros(y1.size) for i in range(x1.size): star_locales = loc_xy[idx[i]] ep1_x = lx1[idx[i]] ep1_y = ly1[idx[i]] poptx, pcovx = curve_fit(linear,star_locales.T,ep1_x) popty, pcovy = curve_fit(linear,star_locales.T,ep1_y) ctx[i] += linear([x2[i],y2[i]],*poptx) cty[i] += linear([x2[i],y2[i]],*popty) shift_x = x1 - ctx shift_y = y1 - cty hdr = 'ID X Y MAG_K MAG_J PMX PMY' fmt = '%d %.3f %.3f %.3f %.3f %f %f' data = np.transpose([ids,x1,y1,mk,mj,shift_x,shift_y]) np.savetxt('./%s/%s' % (pm_folder,ep.split('/')[-1].replace('.mfma','.pm')), data, header=hdr, fmt=fmt)
def fitmagbin(data, mbin, cbins, iteration): import numpy as np from scipy.optimize import curve_fit # N, B = np.histogram(data[ : , 2], bins = cbins) # use for base case N, B = np.histogram(data[ : , 2], bins = cbins, weights = data[ : , 3]) # use for morphology # print np.sum(np.isnan(N)) # no nans show up E = np.sqrt(N) E = np.where(E > 0., E, 2.) # print E bincenters = 0.5 * (B[1:] + B[:-1]) if iteration == 0: opt, cov = curve_fit(func0, bincenters, N, p0 = g_guess[mbin, 0: ], sigma = E, maxfev = 100000) if iteration == 1: opt, cov = curve_fit(func1, bincenters, N, p0 = g_guess[mbin, 2: ], sigma = E, maxfev = 100000) if iteration == 2: opt, cov = curve_fit(func2, bincenters, N, p0 = g_guess[mbin, 4: ], sigma = E, maxfev = 100000) err = np.sqrt(np.diagonal(cov)) err = np.absolute(err) ERR[iteration, mbin, 2 * iteration : ] = err opt = np.absolute(opt) OPT[iteration, mbin, 2 * iteration : ] = opt print 'fit values' fitdata = np.column_stack((opt, err)) print fitdata return N, E, bincenters
def datafit(xdata,ydata,fit_type): ydata = np.power(10.0,ydata/10.0) length = len(xdata) center,minmum = min(enumerate(ydata),key = operator.itemgetter(1)) low_bound = max(center-length/10,0) up_bound = min(center+length/10,len(ydata)) xdata1 = xdata[low_bound:up_bound] ydata1 = ydata[low_bound:up_bound] if (fit_type == 'ratio'): popt, pcov = curve_fit(ratio_fitfunc, xdata1, ydata1) best_value = (2*popt[0]*popt[1] - popt[3])/(2*popt[0]) ch2_amp = AWG.get_ch2amp() qt.msleep(0.1) AWG.set_ch1amp(ch2_amp*best_value) qt.msleep(0.1) elif (fit_type == 'skew'): popt, pcov = curve_fit(skew_fitfunc, xdata1, ydata1) best_value = popt[2] AWG.set_ch1skew(best_value) qt.msleep(0.1) elif (fit_type == 'offset'): popt, pocv = curve_fit(ratio_fitfunc,xdata1,ydata1) best_value = (2*popt[0]*popt[1] - popt[3])/(2*popt[0]) return best_value
def main(): parser = OptionParser(description='Fitting to a noisy data generated by a known function') parser.add_option("--npoints", type="int", help="number of data points") parser.add_option("--low", type="float", help="smallest data point") parser.add_option("--high", type="float", help="highest data point") parser.add_option("--sigma", type="float", help="std of noise") (options, args) = parser.parse_args() pl.figure(1,(7,6)) ax = pl.subplot(1,1,1) pl.connect('key_press_event',kevent.press) sigma = options.sigma Ls = np.append(np.linspace(options.low,options.high,options.npoints),46) nLs = np.linspace(min(Ls),max(Ls),100) Mis = HalfLog(Ls,.5,0.5) errs = np.random.normal(0,sigma, len(Mis)) Mis = Mis+errs pl.errorbar(Ls,Mis,errs,ls='',marker='s',color='b') print sigma/Mis coeff, var_matrix = curve_fit(FreeLog,Ls,Mis,(1.0,1.0,1.0)) err = np.sqrt(np.diagonal(var_matrix)) dof = len(Ls) - len(coeff) chisq = sum(((Mis-FreeLog(Ls,coeff[0],coeff[1],coeff[2]))/sigma)**2) cdf = special.chdtrc(dof,chisq) print 'Free: a = %0.2f(%0.2f); b = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f ' %(coeff[0],err[0],coeff[1],err[1],coeff[2],err[2],cdf) pl.plot(nLs,FreeLog(nLs,coeff[0],coeff[1],coeff[2]),label='Free',color='y') coeff, var_matrix = curve_fit(ZeroLog,Ls,Mis,(1.0,1.0)) err = np.sqrt(np.diagonal(var_matrix)) dof = len(Ls) - len(coeff) chisq = sum(((Mis-ZeroLog(Ls,coeff[0],coeff[1]))/sigma)**2) cdf = special.chdtrc(dof,chisq) print 'Zero: a = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f' %(coeff[0],err[0],coeff[1],err[1],cdf) pl.plot(nLs,ZeroLog(nLs,coeff[0],coeff[1]),label='Zero',color='g') pl.tight_layout() coeff, var_matrix = curve_fit(HalfLog,Ls,Mis,(1.0,1.0)) err = np.sqrt(np.diagonal(var_matrix)) dof = len(Ls) - len(coeff) chisq = sum(((Mis-HalfLog(Ls,coeff[0],coeff[1]))/sigma)**2) cdf = special.chdtrc(dof,chisq) print 'Half: a = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f' %(coeff[0],err[0],coeff[1],err[1],cdf) pl.plot(nLs,HalfLog(nLs,coeff[0],coeff[1]),label='Half',color='b') pl.tight_layout() coeff, var_matrix = curve_fit(OneLog,Ls,Mis,(1.0,1.0)) err = np.sqrt(np.diagonal(var_matrix)) dof = len(Ls) - len(coeff) chisq = sum(((Mis-OneLog(Ls,coeff[0],coeff[1]))/sigma)**2) cdf = special.chdtrc(dof,chisq) print 'Unity: a = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f' %(coeff[0],err[0],coeff[1],err[1],cdf) pl.plot(nLs,OneLog(nLs,coeff[0],coeff[1]),label='Unity',color='r') pl.tight_layout() pl.legend() pl.show()
def psf_lineplot(stack, cut_range = 3.5, z_step = 0.5, r_step=0.097): """ cut_range: where to cut off axis: 0 --- z-direction 1 --- y-direction 2 --- x-direction z_step: step in z-direction r_step: step in x and y direction plot all the three directions and fit to Gaussian to give the FWHM """ figv = plt.figure(figsize=(6,4)) ax = figv.add_subplot(1,1,1) ax.set_xlim([-cut_range,cut_range]) nz, ny, nx = stack.shape cz, cy, cx = np.unravel_index(np.argmax(stack), (nz,ny,nx)) FWHM = np.zeros(3) # plot along z-direction psf_z = stack[:, cy, cx] coord_z = (np.arange(nz)-nz*0.5)*z_step b = np.mean((psf_z[0],psf_z[-1])) a = psf_z.max() - b w0 = 3.00 pz_0 = (a,0,w0,b) popt = optimize.curve_fit(gaussian, coord_z, psf_z, pz_0)[0] FWHM[0] = np.sqrt(popt[2]*0.5)* 2.355 ax.plot(coord_z-popt[1], psf_z, '-ob', linewidth = 2, label = 'z') # plot along y-direction psf_y = stack[cz,:, cx] coord_y = (np.arange(ny)-ny*0.5)*r_step b = np.mean((psf_y[0],psf_y[-1])) a = psf_y.max() - b w0 = 0.50 py_0 = (a,0,w0,b) popt = optimize.curve_fit(gaussian, coord_y, psf_y, py_0)[0] FWHM[1] = np.sqrt(popt[2]*0.5)* 2.355 ax.plot(coord_y-popt[1], psf_y, '->g', linewidth = 2, label = 'y') # plot along x-direction psf_x = stack[cz, cy, :] coord_x = (np.arange(nx)-nx*0.5)*r_step b = np.mean((psf_x[0],psf_x[-1])) a = psf_x.max() - b w0 = 0.50 px_0 = (a,0,w0,b) popt = optimize.curve_fit(gaussian, coord_x, psf_x, px_0)[0] FWHM[2] = np.sqrt(popt[2]*0.5)* 2.355 ax.plot(coord_x-popt[1], psf_x, '-xr', linewidth = 2, label = 'x') ax.legend(['z', 'y', 'x']) ax.set_xlabel('distance (micron)') plt.tight_layout() return figv, FWHM
def waterbulk(input, zcoord, func): #print "WE ARE INSIDE THE FUNCTION WATERBULK" x = input[0] densmean = np.zeros(200) i = 0 start = 0 for slice in range(1,200): ymean = input[slice] At = guess(ymean) popt, pcov = curve_fit(func, x, ymean,[At, 2, 1], maxfev=10000) k = func(0,*popt) densmean[slice]=k if k > 800: start = slice - i i = i + 1 end = start + i densmean2 = np.zeros(i + 1) i2 = 0 for slice2 in range(0,200): ymean = input[slice2] At = guess(ymean) popt, pcov = curve_fit(func, x, ymean,[At, 2, 1], maxfev=10000) k = func(0,*popt) if k > 800: densmean2[i2] = k i2 = i2 + 1 #print "WE ARE IN THE LAST LINE OF THE FUNCTION WATERBULK" return np.median(densmean2)
def twoDParbolicFit(data): """parabolic fit the function z = Amp * max(0, 1 - a*(x-x0)^2 - b*(y-y0)^2) +offset). Since we only need center and width, this function returns center, width, amplitude and offset. """ def oneDParabolic(x, centerX, Amp, a, offset): #print - Amp * ((x-centerX)**2) + C #print offset #return - Amp * ((x-centerX)**2) + C * offset out = Amp * np.maximum( (1 - a * (x - centerX)**2), 0) ** 2+ offset return out #def oneDGaussian(x, centerX,sDevX,Amp,yOffset): # return Amp*np.exp(-0.5*((x-centerX)/sDevX)**2)+yOffset ### Mask out only the area of interest then integrate the data long each axis xSlice = np.sum(data,0) ySlice = np.sum(data,1) ### Initial guesses for 1d fits xOff = np.nanmin(xSlice) maxX = np.nanmax(xSlice)-xOff x0 = np.argmax(xSlice) yOff = np.nanmin(ySlice) maxY = np.nanmax(ySlice)-yOff y0 = np.argmax(ySlice) lengthX = 0 for i in range(len(xSlice)): if xSlice[i] - xOff > 0.2 * maxX: lengthX += 1 lengthY = 0 for i in range(len(ySlice)): if ySlice[i] - yOff > 0.2 * maxY: lengthY += 1 aX = 4./lengthX**2 aY = 4./lengthY**2 AmpX = 4./3. * maxX/sqrt(aY) AmpY = 4./3. * maxY/sqrt(aX) ### 1d fits xVals, yCovar = curve_fit(oneDParabolic,range(len(xSlice)),xSlice,p0=(x0, AmpX, aX, xOff)) x0 = xVals[0] widthX = sqrt(1/xVals[2]) yVals, yCovar = curve_fit(oneDParabolic,range(len(ySlice)),ySlice,p0=(y0, AmpY, aY, yOff)) y0 = yVals[0] widthY = sqrt(1/yVals[2]) Amp = sqrt(xVals[1] * yVals[1] * 9./16. * sqrt(xVals[2] * yVals[2]) ) offset = 0.5 * (xVals[3]/(np.shape(data)[1]) + yVals[3]/(np.shape(data)[0])) return [[x0, y0], [widthX, widthY], Amp, offset]
def gauss_fit(xdata, ydata, withoffset=True, trim=None, guess_z=None): """Utility function for fitting single variable gaussian data""" # estimate the offset offset = ydata.min() ydata_corr = ydata - offset # make parameter guesses if none giben if guess_z is None: x0 = nmoment(xdata, ydata_corr, 0, 1) else: x0 = guess_z sigma_x = np.sqrt(nmoment(xdata, ydata_corr, x0, 2)) p0 = np.array([ydata_corr.max(), x0, sigma_x, offset]) # trim data if requested if trim is not None: args = abs(xdata - x0) < trim * sigma_x xdata = xdata[args] ydata = ydata[args] # do actual fitting try: if withoffset: popt, pcov = curve_fit(gauss, xdata, ydata, p0=p0) else: popt, pcov = curve_fit(gauss_no_offset, xdata, ydata, p0=p0[:3]) popt = np.insert(popt, 3, offset) except RuntimeError: popt = p0 * np.nan # return result return popt
def draw_fit(rl, pct): """Draw sigmoid for psychometric rl: x values pct: y values Fxn draws the curve """ def sig(x, A, x0, k, y0): return A / (1 + np.exp(-k*(x-x0))) + y0 def sig2(x, x0, k): return 1. / (1+np.exp(-k*(x-x0))) pl.xlabel('R-L stimuli') pl.ylabel('p(choose R)') pl.xlim([rl.min()-1, rl.max()+1]) pl.ylim([-0.05, 1.05]) popt,pcov = curve_fit(sig, rl, pct) # stretch and yshift are free params popt2,pcov2 = curve_fit(sig2, rl, pct) # stretch and yshift are fixed x = np.linspace(rl.min(), rl.max(), 200) y = sig(x, *popt) y2 = sig2(x, *popt2) pl.vlines(0,0,1,linestyles='--') pl.hlines(0.5,rl.min(),rl.max(),linestyles='--') pl.plot(x,y) #pl.plot(x,y2) return popt
def fitParam(paths,identifier): #paths should be ordered in theta x0 = defaultdict(list) for path in paths: res, df = parametrizeBias([path],level=0) x0['a'].append(res.x[0]) x0['b'].append(np.abs(res.x[1])) x0['theta'].append(int(np.unique(degrees_(df['theta']).apply(round)))) x0 = pd.DataFrame(x0) colors = plt.cm.Set1(np.linspace(0, 1, 2)) fig = plt.figure(figsize=(8,5)) ax = fig.add_subplot(111) ax.scatter(np.array(x0['theta']),np.array(x0['a']),marker='s',s=30,c=colors[0],lw=0) ax.scatter(np.array(x0['theta']),np.array(x0['b']),marker='o',s=30,c=colors[1],lw=0) ths = np.linspace(x0['theta'].min(),x0['theta'].max(),100) a0, acov_lin = curve_fit(a,np.array(x0['theta'])*np.pi/180.,x0['a']) b0, bcov_quad= curve_fit(b,np.array(x0['theta'])[1:]*np.pi/180.,np.array(x0['b'])[1:]) ax.plot(ths,a(np.array(ths)*np.pi/180.,*a0),lw=2,label = "$a$",c=colors[0]) ax.plot(ths,b(np.array(ths)*np.pi/180.,*b0),lw=2,label = "$b$",c=colors[1]) customAx(ax,xlabel=r'$\theta/^{\circ}$',ylabel="$p$",xlim=[x0['theta'].min()-1,x0['theta'].max()+1],legloc=2,ncol=1,bbox=None, fontS=18,frameon=False,xscale_log=False,yscale_log=False,ticklabelsize=18,labelsize=22,legend=True, handleL=1,colSp=.2,labelSp=0.001,handleTp=.1,borderP=.2,yaxis_labelpad=5) ax.minorticks_on() figpath = 'pics/RecEff' figname = 'fitbiasparam_theta_%(identifier)s.pdf'%locals() print 'save fig', figname fig.savefig('%(figpath)s/%(figname)s'%locals(),bbox_inches='tight') return x0
def cruvefit(std, window, peak, stdamp, popendiff): fitpeak = np.array([]) fitpopendiff = np.array([]) fitstdamp = np.array([]) fitwindow = np.array([]) failedattemp = 'interval:' + str(window) failedattempcount = 0 for tpeak in range(len(peak)): xdata = np.arange(peak[tpeak]-(window-1)*precentage, peak[tpeak]+(window-1)*precentage+1) ydata = std[peak[tpeak]-(window-1)*precentage: peak[tpeak]+(window-1)*precentage+1] guess = [peak[tpeak], popendiff[tpeak]] params, params_covariance = optimize.curve_fit(funstd, xdata, ydata, guess) if funstd(params[0], params[0], params[1]) < (0.5*std[params[0]]): print 'Curve fit based on Popen solved from standard deviation peak failed.' print 'Peak time', peak[tpeak], 'Retry for maximum of ten times.' count = 1 while count < 11: params, params_covariance = optimize.curve_fit(funstd,xdata,ydata,guess) if funstd(params[0], params[0], params[1]) < (0.5*std[params[0]]): count += 1 else: print 'Retrying:', str(count), 'of 10','success' count += 100 if count == 11: print peak[tpeak], 'Curve fitting failed', 'Using initial guess instead' failedattemp += ' ' + str(peak[tpeak]) failedattempcount += 1 params[0] = peak[tpeak] params[1] = popendiff[tpeak] fitpeak = np.append(fitpeak, params[0]) fitpopendiff = np.append(fitpopendiff, params[1]) fitstdamp = np.append(fitstdamp, funstd(params[0], params[0], params[1])) failedattemp += ' ' + str(failedattempcount) + ' out of ' + str(len(fitpeak)) + 'failed' return fitpeak, fitpopendiff, fitstdamp, failedattemp
def bootstrap(data, H_0): ''' Simulación de bootstrap para encontrar el intervalo de confianza (95%) ''' N, N1 = data.shape N_boot = 10000 H = np.zeros(N_boot) for i in range(N_boot): s = np.random.randint(low=0, high=N, size=N) fake_data = data[s][s] v = fake_data[:, 0] d = fake_data[:, 1] a_optimo1, a_covarianza1 = curve_fit(funcion_a_minimizar1, d, v, 2) a_optimo2, a_covarianza2 = curve_fit(funcion_a_minimizar2, v, d, 2) a_promedio = (a_optimo2 + a_optimo1) / 2 H[i] = a_promedio fig2, ax2 = plt.subplots() plt.hist(H, bins=30) plt.axvline(H_0, color='r', label="valor obtenido de H0") plt.legend(loc=2) ax2.set_title("Simulacion bootstrap") ax2.set_xlabel("H [Km/s /Mpc]") ax2.set_ylabel("frecuencia") plt.savefig("bootstrap_2.jpg") H = np.sort(H) limite_bajo = H[int(N_boot * 0.025)] limite_alto = H[int(N_boot * 0.975)] print "El intervalo de confianza al 95% es: [{}:{}]".format(limite_bajo, limite_alto)
def bias_corrector_sigma(self, model_func, b, rice_sig, sigma, ind_break, guess, bound, weight, sigdiff_break=.02, N_break=100): """ Algorithm Implementation without sigma estimation Run Bias Correction model_func: underlying model function b: array of b-factors (b=gamma^2*g^2*delta^2*(Delta-delta/3)) [s/mm^2] rice_sig: signal to be corrected (Rician distributed) guess: initial guess for the fit funtion (must be set; not None) bound: bounds for the fit weight: use weighting of datapoints (rician) num_sigmaes_avrg: "number of freedom" for sigmaes calculation """ #array for corrected signal rice_sig_corr = np.zeros_like(rice_sig) #set dimensions and number of fitting parameters num_dp = np.prod(b.shape) #number of datapoints in signal if ind_break is None: ind_break = int(num_dp / 2.) # index for break criterium num_fp = len(guess) #number of fitting parameters #effective number of datapoints for sigmaes calculation #list for run parameters para_run_arr = np.zeros((self.N_break, len(guess) + 1)) #saving fitting errors (keep as list for the moment) para_run_err = [] #STEP 1 #fit exp and obtain ŝ_0 (fit_sig) and RMSE res = so.curve_fit( model_func, b, rice_sig_corr, guess, bounds=bound, method=method_grad, ) if res is False: if self.debug: print('Problem with Fit!') return None fit_sig = model_func(b, *res[0]) # FIX parameter input #save parameters of first fit and estimation para_run_arr[0, :-1] = res[0] para_run_arr[0, -1] = sigma para_run_err.append(res[1]) for i in np.arange(1, N_break): #STEP 3 + 4 #Estimate Rician bias and calculate corrected signal rice_sig_corr = rice_sig - (self.rice_mean_high(fit_sig, sigma) - fit_sig) #STEP 5 #fit exp res = so.curve_fit( model_func, b, rice_sig_corr, guess, bounds=bound, method=method_grad, ) if res is False: if self.debug: print('Problem with Fit!') return None fit_sig_bf = np.copy(fit_sig) fit_sig = model_func(b, *res[0]) #step 6 if 1 == 1: para_run_arr[i, :-1] = res[0] para_run_arr[i, -1] = sigma para_run_err.append(res[1]) #step 8 stopping crit if np.max( np.abs(fit_sig[ind_break] - fit_sig_bf[ind_break]) / fit_sig[ind_break]) < sigdiff_break: break return [para_run_arr[:i + 1], para_run_err, i]
FWHM = np.zeros(N) V_span = np.zeros(N) BIS = np.zeros(N) v_CCF = np.linspace(-20, 20, 401) idx0 = (v_CCF >= -10) & (v_CCF <= 10) v_ccf = v_CCF[idx0] for i in range(N): filename = DIR + '/fits/CCF' + str(i) + '.dat' # filename = DIR + '/CCF_noise' + '%d' %SN[n] + '/' + str(i) + '.dat' CCF = 1 - np.loadtxt(filename) ccf = CCF[idx0] # popt, pcov = curve_fit(gaussian, v_ccf, ccf) popt, pcov = curve_fit(gaussian, v_CCF, CCF) popt0 = popt # Keep a snapshot RV[i] = popt[1] # km/s FWHM[i] = popt[2] * math.sqrt(8*math.log(2)) sigma = FWHM[i]/2 # performs better than sigma = popt[2] # sigma = popt[2] ################### # Calculate Vspan # ################### # σ is the width of the CCF # I take σ as the FWHM # oversample v_CCF from scipy.interpolate import interp1d f = interp1d(v_CCF, CCF, kind='cubic')
dates = dates[i0:] if province != 'Hubei': maxt = 12 else: maxt = 19 i1 = np.where(t <= maxt)[0][-1] _t = t[:i1 + 1] _cases = cases[:i1 + 1] print(t, cases) if len(t) < 8: continue f = lambda x, mu, B: B * x**mu p, _ = curve_fit(f, _t, _cases, [1.9, 4.5]) print(p) tt = np.logspace(np.log(t[0]), np.log(t[-1]), base=np.exp(1)) tt_dates = np.array((tt - 1) * 24 * 3600, np.timedelta64) + dates[0] print(dates, tt_dates) pl.sca(ax[i]) pl.plot_date(dates, cases, marker=markers[i], c=colors[i], label=titlemap[province], mfc='None')
def fitUtilityFunction(X,Y,func): from scipy.optimize import curve_fit curve_opt, curve_cov = curve_fit(func,X,Y, maxfev=20000) # fit the observed data, try 20,000 iterations # print(curve_opt) return curve_opt
a, b, c = params return a*np.exp(-b*x) + c def error(params, x, y): return y - func(params, x) def error2(params, x, y): return (y - func(params, x))**2 x = np.linspace(0,4,50) params = np.array([2.5, 1.3, 0.5]) y0 = func(params, x) y = y0 + 0.2*np.random.normal(size=len(x)) res = optimize.leastsq(error, params, args=(x, y), full_output=True) ## r, R, c = getjaccov(res[1:], 3) mod = Myfunc(y, x) resmy = mod.fit(nparams=3) cf_params, cf_pcov = optimize.curve_fit(func0, x, y) cf_bse = np.sqrt(np.diag(cf_pcov)) print(res[0]) print(cf_params) print(resmy.params) print(cf_bse) print(resmy.bse)
plt.savefig('build/magnetfeld.pdf') makeTable([z[:10], B[:10]], r'{$z/\si{\milli\metre}$} & {$B/\si{\milli\tesla}$}', 'magnetfeld', ['S[table-format=2.0]', 'S[table-format=3.0]'], ["%2.0f", "%3.0f"]) makeTable([z[9:], B[9:]], r'{$z/\si{\milli\metre}$} & {$B/\si{\milli\tesla}$}', 'magnetfeld2', ['S[table-format=2.0]', 'S[table-format=3.0]'], ["%2.0f", "%3.0f"]) #reinprobe print('reinprobe') l,t1,t2 = np.genfromtxt('scripts/reinprobe.txt',unpack=True) # micrometer, degree tr = (t1-t2)/2 tr = 2*np.pi*tr/360 # rad tr = tr/5.11*10**3 #rad/m def hyperbel(l,a): return a/l**2 params, covariance_matrix = curve_fit(hyperbel,l,tr) errors = np.sqrt(np.diag(covariance_matrix)) x = np.linspace(0.9,2.7,1000) plt.cla() plt.clf() plt.plot(l**2,tr,'rx',label=r'Messwerte') plt.plot(x**2,hyperbel(x,*params),'b-',label=r'Ausgleichskurve') plt.xlabel(r'$\lambda^2/\si{\micro\metre\squared}$') plt.ylabel(r'$\Delta\theta/\si{\text{rad}\per\metre}$') plt.xlim(0.9,7.2) plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.legend(loc='best') plt.savefig('build/reinprobe.pdf') print('a=',unp.uarray(params[0],errors[0]))
def smooth(wvl, flux, cut_vel, unc_arr=False): """ Smoothes spectra by separating SN features from noise in Fourier space. Python implementation of the IDL smoothing technique introduced by Liu et al. 2016 (https://github.com/nyusngroup/SESNspectraLib/blob/master/SNspecFFTsmooth.pro) Parameters ---------- wvl : np.array wavelength array flux : np.array flux array cut_vel : float velocity cut for SN features. Recommended 1000 km/s for non IcBL spectra and 3000 km/s for IcBL spectra. unc_arr : Boolean Calculates uncertainty array if True. Returns ------- w_smoothed : np.array wavelength array for smoothed fluxes f_smoothed : np.array smoothed flux array sepvel : float velocity for separating SN features. """ c_kms = 299792.47 # speed of light in km/s vel_toolarge = 100000 # km/s width = 100 wvl_ln = np.log(wvl) num = wvl_ln.shape[0] binsize = wvl_ln[-1] - wvl_ln[-2] f_bin, wln_bin = binspec(wvl_ln, flux, min(wvl_ln), max(wvl_ln), binsize) fbin_ft = np.fft.fft(f_bin) #*len(f_bin) freq = np.fft.fftfreq(num) num_upper = np.max(np.where(1.0 / freq[1:] * c_kms * binsize > cut_vel)) num_lower = np.max( np.where(1.0 / freq[1:] * c_kms * binsize > vel_toolarge)) mag_avg = np.mean(np.abs(fbin_ft[num_lower:num_upper + 1])) powerlaw = lambda x, amp, exp: amp * x**exp num_bin = len(f_bin) xdat = freq[num_lower:num_upper] ydat = np.abs(fbin_ft[num_lower:num_upper]) nonzero_mask = xdat != 0 slope, intercept, _, _, _ = st.linregress(np.log(xdat[nonzero_mask]), np.log(ydat[nonzero_mask])) exp_guess = slope amp_guess = np.exp(intercept) #do powerlaw fit xdat = freq[num_lower:int(num_bin / 2)] ydat = np.abs(fbin_ft[num_lower:int(num_bin / 2)]) #exclude data where x=0 because this can cause 1/0 errors if exp < 0 finite_mask = np.logical_not(xdat == 0) finite_mask = np.logical_and(finite_mask, np.isfinite(ydat)) ampfit, expfit = opt.curve_fit(powerlaw, xdat[finite_mask], ydat[finite_mask], p0=[amp_guess, exp_guess])[0] #find intersection of average fbin_ft magnitude and powerlaw fit to calculate separation #velocity between signal and noise. intersect_x = np.power((mag_avg / ampfit), 1.0 / expfit) sep_vel = 1.0 / intersect_x * c_kms * binsize #filter out frequencies with velocities higher than sep_vel smooth_fbin_ft = np.array([fbin_ft[ind] if np.abs(freq[ind])<np.abs(intersect_x) else 0 \ for ind in range(len(freq))])#/len(f_bin) #inverse fft on smoothed fluxes smooth_fbin_ft_inv = np.real(np.fft.ifft(smooth_fbin_ft)) #interpolate smoothed fluxes back onto original wavelengths w_smoothed = np.exp(wln_bin) f_smoothed = np.interp(wvl, w_smoothed, smooth_fbin_ft_inv) if unc_arr: f_resi = flux - f_smoothed num = len(f_resi) bin_size = int(np.floor( width / (wvl[1] - wvl[0]))) # window width in number of bins bin_rad = int(np.floor(bin_size / 2)) f_std = np.zeros(num) start_ind = bin_rad end_ind = num - bin_rad for j in np.arange(start_ind, end_ind): f_std[j] = np.std(f_resi[j - bin_rad:j + bin_rad + 1]) for j in np.arange(1, bin_rad): f_std[j] = np.std(f_resi[0:2 * j + 1]) for j in np.arange(end_ind, num - 1): f_std[j] = np.std(f_resi[2 * j - num + 1:]) f_std[0] = np.abs(f_resi[0]) f_std[-1] = np.abs(f_resi[-1]) return w_smoothed, f_smoothed, sep_vel, f_std return w_smoothed, f_smoothed, sep_vel
def main(): # print(Strukturamplitude(gitter = 'SC')) # print(Strukturamplitude(gitter = 'FCC')) # print(Strukturamplitude(gitter = 'BCC')) gitter_moegl = ['SC','FCC','BCC','Diamant'] Xi2_best = ['SC', 10] #################################################################################################### # Metall #################################################################################################### print('\n#################### Analyse für Metall ####################\n') # print('\n') #Bogenlängenformel b=alpha*r*pi /180 # theta_4 = radius_m * 180 / (np.pi * Radius_k) theta_4_temp = radius_m * 180 / (np.pi * Radius_k) # in Grad! theta_4_rueck = (radius_m_rueck * 180 / (np.pi * Radius_k)) #+ 180 # in Grad! theta_4 = np.concatenate((theta_4_temp, theta_4_rueck), axis = 0) print('Hier!!!!!!!!!!!:' ,theta_4) theta = theta_4 * np.pi / (4 * 180) # in radianten theta = np.sort(theta) theta_sin = np.sin(theta) # hier für die Fehlerfortpfalnzung aufgrund der ungenauigkeit des Lineals radius_metall_temp = unp.uarray(radius_m, Fehler_radius) radius_metall_rueck = unp.uarray(radius_m_rueck, Fehler_radius) radius_metall = np.concatenate((radius_metall_temp, radius_metall_rueck), axis = 0) Radius_kamera = ufloat(Radius_k, 0.0) theta_4_unp = radius_metall * 180 / (np.pi * Radius_kamera) theta_unp = theta_4_unp * np.pi / (4 * 180) # in radianten theta_unp = np.sort(theta_unp) print('Theta mit Fehler: ', theta_unp) netzebenenabstand_metall = bragg(lambda_1, theta) for gitter in gitter_moegl: infos = Strukturamplitude(gitter = gitter) reflexe = infos[0] m = infos[1] verhaeltnisse = findStructure(m, netzebenenabstand_metall) verhaeltnis_m = verhaeltnisse[0] verhaeltnis_d = verhaeltnisse[1] print('Verhältnisse für die m Werte: ', verhaeltnis_m) print('Verhältnisse für die d Werte: ', verhaeltnis_d) print('Abweichung Xi^2 für die ' + gitter + ' Sturktur: ', abweichung(verhaeltnis_m, verhaeltnis_d)) if abweichung(verhaeltnis_m, verhaeltnis_d) < Xi2_best[1]: Xi2_best = [gitter, abweichung(verhaeltnis_m, verhaeltnis_d)] print('Struktur mit der kleinsten Abweichung: ', Xi2_best[0]) print('Abweichung Xi^2: ', Xi2_best[1]) m = Strukturamplitude(gitter = Xi2_best[0])[1] a = np.array(gitterkonstanteBragg(m, netzebenenabstand_metall)) print('Gitterkonstanten für ' + Xi2_best[0] + ' Struktur: ', a) # linearer fit für a gegen cos^2 params, cov = curve_fit(lin,np.cos(theta)**2,a) # params, cov = curve_fit(lin,np.cos(theta),a) err = np.sqrt(np.diag(cov)) a_extrp = ufloat(params[1], err[1]) # systematischer Fehler Absorption der Röntgenstrahlung DeltaA = (radius_rohr / (2 * Radius_k)) * (1 - Radius_k / Abstand_FP) * (np.cos(theta)**2 / theta) * a # cos2Theta = [] # for i in range(0,len(theta)): # cos2Theta.append(ufloat(theta[i], Fehler_Theta[i])) cos2Theta = unp.cos(theta_unp)**2 a_mitFehler = unp.uarray(a, DeltaA) print('Gitterkonstanten mit Fehler durch die Absorption: ', a_mitFehler) print('Extrapolierte Gitterkonstante: ', a_extrp) cos2Theta_fit = np.linspace(0, 1) ####### ab hier der a gegen cos^2 Plot ######## # plt.plot(np.cos(theta)**2, a, 'x', label = 'Daten') plt.errorbar(np.cos(theta)**2, a, xerr=stds(cos2Theta), yerr=DeltaA, fmt='x', label = 'Daten') # plt.plot(np.cos(theta), a, 'x', label = 'Daten') plt.plot(cos2Theta_fit, lin(cos2Theta_fit, *params), label = 'Fit') plt.legend(loc = 'best') plt.xlabel('cos$^2(\Theta)$') plt.ylabel('$a$ in Angtröm') # plt.xlim(0.6,1) # plt.ylim(4.8e-10,5.8e-10) plt.tight_layout() plt.grid() plt.savefig('Plots/Metall_Fit.pdf') plt.close() #################################################################################################### # Salz #################################################################################################### print('\n#################### Analyse für Salz ####################\n') gitter_moegl_Salz = ['Zinkblende', 'Steinsalz', 'Caesiumchlorid', 'Fluorit'] Xi2_best_Salz = ['Zinkblende', 10, 'CuCl'] ion_zink = [['Cu', 'Cl'], ['Cs', 'J'], ['Cu', 'J']] #Bogenlängenformel b=alpha*r*pi /180 # theta_4 = radius_s * 180 / (np.pi * Radius_k) theta_4_temp = radius_s * 180 / (np.pi * Radius_k) # in Grad! theta_4_rueck = (radius_s_rueck * 180 / (np.pi * Radius_k))# + 180 # in Grad! theta_4 = np.concatenate((theta_4_temp, theta_4_rueck), axis = 0) print('Hier!!!!!!!!!!!:' ,theta_4) theta = theta_4 * np.pi / (4 * 180) # in radianten theta = np.sort(theta) theta_sin = np.sin(theta) # hier für die Fehlerfortpfalnzung aufgrund der ungenauigkeit des Lineals # radius_salz = unp.uarray(radius_s, Fehler_radius) radius_salz_temp = unp.uarray(radius_s, Fehler_radius) radius_salz_rueck = unp.uarray(radius_s_rueck, Fehler_radius) radius_salz = np.concatenate((radius_salz_temp, radius_salz_rueck), axis = 0) print('Hier!!!???!?!?!?!: ', radius_salz) Radius_kamera = ufloat(Radius_k, 0.0) theta_4_unp = radius_salz * 180 / (np.pi * Radius_kamera) theta_unp = theta_4_unp * np.pi / (4 * 180) # in radianten theta_unp = np.sort(theta_unp) print('Theta mit Fehler: ', theta_unp) netzebenenabstand_salz = bragg(lambda_1, theta) for gitter in gitter_moegl_Salz: # reflexe = [] # m = [] # if gitter == 'Zinkblende': # for ion in ion_zink: # temp_Salz = Strukturamplitude_Salz(formfaktor(, lambda_1,ion[0]), formfaktor(ion[1]), 'Zinkblende') # wie mit theta???? # reflexe = temp_Salz[0] # m = temp_Salz[1] # verhaeltnisse = findStructure(m, netzebenenabstand_salz) # verhaeltnis_m = verhaeltnisse[0] # verhaeltnis_d = verhaeltnisse[1] # print('Verhältnisse für die m Werte: ', verhaeltnis_m) # print('Verhältnisse für die d Werte: ', verhaeltnis_d) # print('Abweichung Xi^2 für die ' + gitter + ' Sturktur mit' + ion[0] + ion[1] + ' : ', abweichung(verhaeltnis_m, verhaeltnis_d)) # if abweichung(verhaeltnis_m, verhaeltnis_d) < Xi2_best_Salz[1]: # Xi2_best_Salz = [gitter, abweichung(verhaeltnis_m, verhaeltnis_d), ion[0] + ion[1]] # elif gitter == 'Steinsalz': # temp_Salz = Strukturamplitude_Salz(ion[0], ion[1], 'Zinkblende') # reflexe = temp_Salz[0] # m = temp_Salz[1] # verhaeltnisse = findStructure(m, netzebenenabstand_salz) # verhaeltnis_m = verhaeltnisse[0] # verhaeltnis_d = verhaeltnisse[1] # print('Verhältnisse für die m Werte: ', verhaeltnis_m) # print('Verhältnisse für die d Werte: ', verhaeltnis_d) # print('Abweichung Xi^2 für die ' + gitter + ' Sturktur mit' + ion[0] + ion[1] + ' : ', abweichung(verhaeltnis_m, verhaeltnis_d)) # if abweichung(verhaeltnis_m, verhaeltnis_d) < Xi2_best_Salz[1]: # Xi2_best_Salz = [gitter, abweichung(verhaeltnis_m, verhaeltnis_d), ion[0] + ion[1]] infos = Strukturamplitude_Salz(f1 = 1, f2 = 2, gitter = gitter) reflexe = infos[0] m = infos[1] verhaeltnisse = findStructure(m, netzebenenabstand_salz) verhaeltnis_m = verhaeltnisse[0] verhaeltnis_d = verhaeltnisse[1] print('Verhältnisse für die m Werte: ', verhaeltnis_m) print('Verhältnisse für die d Werte: ', verhaeltnis_d) print('Abweichung Xi^2 für die ' + gitter + ' Sturktur: ', abweichung(verhaeltnis_m, verhaeltnis_d)) if abweichung(verhaeltnis_m, verhaeltnis_d) < Xi2_best_Salz[1]: Xi2_best_Salz = [gitter, abweichung(verhaeltnis_m, verhaeltnis_d)] print('Struktur mit der kleinsten Abweichung: ', Xi2_best_Salz[0]) print('Abweichung Xi^2: ', Xi2_best_Salz[1]) m = Strukturamplitude_Salz(gitter = Xi2_best_Salz[0])[1] a = np.array(gitterkonstanteBragg(m, netzebenenabstand_salz)) print('Gitterkonstanten für ' + Xi2_best_Salz[0] + ' Struktur: ', a) #linearer fit für a gegen cos^2 params, cov = curve_fit(lin,np.cos(theta)**2,a) # params, cov = curve_fit(lin,np.cos(theta),a) err = np.sqrt(np.diag(cov)) a_extrp = ufloat(params[1], err[1]) # systematischer Fehler Absorption der Röntgenstrahlung DeltaA = (radius_rohr / (2 * Radius_k)) * (1 - Radius_k / Abstand_FP) * (np.cos(theta)**2 / theta) * a # cos2Theta = [] # for i in range(0,len(theta)): # cos2Theta.append(ufloat(theta[i], Fehler_Theta[i])) cos2Theta = unp.cos(theta_unp)**2 a_mitFehler = unp.uarray(a, DeltaA) print('Gitterkonstanten mit Fehler durch die Absorption: ', a_mitFehler) print('Extrapolierte Gitterkonstante: ', a_extrp) cos2Theta_fit = np.linspace(0, 1) ####### ab hier der a gegen cos^2 Plot ######## # plt.plot(np.cos(theta)**2, a, 'x', label = 'Daten') plt.errorbar(np.cos(theta)**2, a, xerr=stds(cos2Theta), yerr=DeltaA, fmt='x', label = 'Daten') # plt.plot(np.cos(theta), a, 'x', label = 'Daten') plt.plot(cos2Theta_fit, lin(cos2Theta_fit, *params), label = 'Fit') plt.legend(loc = 'best') plt.xlabel('cos$^2(\Theta)$') plt.ylabel('$a$ in Angtröm') # plt.xlim(0.5,1) # plt.ylim(4.8e-10,5.8e-10) plt.tight_layout() plt.grid() plt.savefig('Plots/Salz_Fit.pdf') plt.close()
def approximate_data( self, include_countries=('All', ), exclude_countries=('All', ), include_province=('All', ), exclude_province=('All', ), quality=('good', 'ok'), ): if not len(self.df_cases) or not len(self.df_deaths): raise ValueError( 'Data has not been loaded properly. Call load_data_jh() method first.' ) data = [] # type: [DataEstimate] for i, deaths_row in self.df_deaths.iterrows(): try: # row = df.iloc[0] # Get one row of data. row_province = deaths_row[0] row_country = deaths_row[1] # Filter by country. if 'All' in include_countries: if row_country in exclude_countries: continue elif row_country not in include_countries: continue # Filter by region. if 'All' in include_province: if row_province in exclude_province: continue elif row_province not in include_province: continue deaths_row = deaths_row.iloc[ 4:] # Cut meta data at the beginning. row_days = deaths_row.index.to_series( ) # Split dates info a separate series. row_days = row_days.apply( jh_date_to_dofy) # Convert dates into days of the year. # Get real cases in the same format. if row_province: cases = self.df_cases.loc[ (self.df_cases['Province/State'] == row_province) & (self.df_cases['Country/Region'] == row_country ) # Sort by the same country and province. ].iloc[0].iloc[ 4:] # [1] gets the Series out of next() results, iloc[4:] cuts the unused meta data from the beginning. else: cases = self.df_cases.loc[ self.df_cases['Country/Region'] == row_country # Sort by the same country and province. ].iloc[0].iloc[ 4:] # [1] gets the Series out of next() results, iloc[4:] cuts the unused meta data from the beginning. # If we have less than 20 cases or 7 days of data or if the reported death rate is above 10%, # we cannot really estimate anything. if (deaths_row.tail(1)[0] < 20 or deaths_row.tail(7)[4] < 1 or (deaths_row.sum() / cases.sum() * 100) > 10): continue population = 500000 if row_country == 'US' and row_province in self.states_population[ 'state'].tolist(): population = int(self.states_population.loc[ self.states_population['state'] == row_province] ['population']) # Find the model fit. fit = curve_fit( self.logistic_model, list( row_days.iloc[deaths_row.to_numpy().nonzero()[0][0]:]), list(deaths_row.iloc[deaths_row.to_numpy().nonzero( )[0][0]:]), # p0=[2, 10, 200000], bounds=( (1, 1, 1e4), (200, 1000, 3e7), ), check_finite=True, maxfev=population, ) fit_a = fit[0][0] error_a = np.sqrt(fit[1][0][0]) fit_peak_days = fit[0][1] error_peak_days = np.sqrt(fit[1][1][1]) fit_c = fit[0][2] error_cases = np.sqrt(fit[1][2][2]) # Make an estimated row with day # as values and dates as indexes. cases_approximation = pd.Series(row_days, index=deaths_row.index)\ .apply( lambda x: int(self.logistic_model((x+self.avg_days_to_death), fit_a, fit_peak_days, fit_c)/self.mortality_rate*100) ) # Just a quick estimate. tail_cases_doubling_2d = float( deaths_row.tail(1)) / self.mortality_rate * 100 * 2**( self.avg_days_to_death / 2) tail_cases_doubling_4d = float( deaths_row.tail(1)) / self.mortality_rate * 100 * 2**( self.avg_days_to_death / 4) tail_cases_doubling_6d = float( deaths_row.tail(1)) / self.mortality_rate * 100 * 2**( self.avg_days_to_death / 6) # Estimated cases as of today. tail_cases_approximation = int(cases_approximation.tail(1)) # If the estimation shows that there are more cases than an estimation with 2-day doubling rate, it's likely bad. if error_a > 3 or error_peak_days > 150 or error_cases > population * 0.01 or tail_cases_approximation > tail_cases_doubling_2d: estimate = 'bad' # Skipp cases with not specified quality. if 'bad' not in quality: continue elif error_a > 1 or error_peak_days > 50 or error_cases > population * 0.001: # Skipp cases with not specified quality. if 'ok' not in quality: continue estimate = 'ok' else: # Skipp cases with not specified quality. if 'good' not in quality: continue estimate = 'good' data.append( DataEstimate( id=i, province=row_province, country=row_country, cases_approximation=cases_approximation, cases=cases, estimate=estimate, error_cases=error_cases, error_peak=error_peak_days, peak_day=fit_peak_days, )) except IndexError: # Some states don't have any data yet, so we just skipp them. continue # Sort data by fitment. data = sorted(data, key=lambda x: (x.estimate_order, x.error_cases)) return data
def bias_corrector(self, model_func, b, rice_sig, guess, bound, res_func=None, weight=None, num_sigmaes_avrg=0, N_avrg=1, sigdiff_break=.02, N_break=100): """ Algorithm Implementation Run Bias Correction model_func: underlying model function b: array of b-factors (b=gamma^2*g^2*delta^2*(Delta-delta/3)) [s/mm^2] rice_sig: signal to be corrected (Rician distributed) guess: initial guess for the fit funtion (must be set; not None) bound: bounds for the fit weight: use weighting of datapoints (rician) num_sigmaes_avrg: "number of freedom" for sigmaes calculation N_avrg: factor for actual sigma if signal is averaged """ if res_func is None: def res_func(SNR): return self.alpha_func(SNR, N=N_avrg) rice_sig_corr = np.zeros_like(rice_sig) #set dimensions and number of fitting parameters num_dp = rice_sig.shape[0] num_fp = len(guess) #number of fitting parameters #effective number of datapoints for sigmaes calculation num_siges = num_dp - num_sigmaes_avrg #list for run parameters para_run_arr = np.zeros((self.N_break, len(guess) + 1)) #saving fitting errors (keep as list for the moment) para_run_err = [] #STEP 1 #fit exp and obtain ŝ_0 (fit_sig) and RMSE res = so.curve_fit(model_func, b, rice_sig, guess, bounds=bound, method=method_grad) if res is False: if self.debug: print('Problem with Fit!') return None fit_sig = model_func(b, *res[0]) # FIX parameter input RMSE = np.sqrt(np.sum((fit_sig - rice_sig)**2) / (num_dp - num_fp)) #STEP 2 #get RMSE sigma_corr_fac_RMSE = np.sqrt(N_avrg) sigma_es = RMSE * sigma_corr_fac_RMSE #save parameters of first fit and estimation para_run_arr[0, :-1] = res[0] para_run_arr[0, -1] = sigma_es para_run_err.append(res[1]) for i in np.arange(1, N_break): #STEP 3 + 4 #Estimate Rician bias and calculate corrected signal rice_sig_corr = rice_sig - ( self.rice_mean_high(fit_sig, sigma_es) - fit_sig) #STEP 5 res = so.curve_fit(model_func, b, rice_sig_corr, guess, bounds=bound, method=method_grad) if res is False: if self.debug: print('Problem with Fit!') return None fit_sig = model_func(b, *res[0]) #step 6+7 #get new alpha and estimate sigma SNR_es = fit_sig / sigma_es alpha = res_func(SNR_es) sigma_es_bf = np.copy(sigma_es) sigma_es = np.sum(np.abs(fit_sig - rice_sig) / alpha) / num_siges if 1 == 1: para_run_arr[i, :-1] = res[0] para_run_arr[i, -1] = sigma_es para_run_err.append(res[1]) #step 8 stopping crit if np.abs(sigma_es - sigma_es_bf) / sigma_es < sigdiff_break: break return [para_run_arr[:i + 1], para_run_err, i]
def get_decay_feats(peak_xt, plot_me=False): ''' Using the locations for each peak, extracts features for model. It will calculate when the peak returns to baseline and use it and the peak to calculate an exponential fit. This will be used to generate Tau and AUC. It will also return the time domain for ea ch peak as well as the percent baseline used to determine what the peak must return to to be considered baseline. :param peak_xt: Array of currrent values surrounding the peak in question. :param plot_me: When this is true, will plot the exponential fit of each peak to the calculated baseline. :return: tau: The negative inverse of the dampening coefficeint fo the exponential fit (-1/b) r2_decay: The r2 value for the exponential fit auc: Area under the curve of the fitted exponential equation. NOT the AUC for the whole peak, just after the peak. perc: The percent peak height used to find the baseline. ''' # Sets starting values for determining a return to baseline val = 1000 perc = 0.001 # Finds the return to baseline index for the peak. If the initial range is unsuccessful, it will expand # potential trace by 10% and increase the allowed percent return to double. This will occur until a minimum is # found. y_mins = [] while len(y_mins) == 0: search_area = list(trace_s[peak_xt:peak_xt + val]) # print(search_area) y_mins = [(abs(x), search_area.index(x)) for x in search_area if x <= peak_y[1] * perc] # print(y_mins) perc = 2 * perc val = val + int(np.round(val * 1.1)) perc = (perc / 2) y_min = y_mins[0] def exp_func(x, a, b): ''' Exponential function for the fit. :param x: Input varibale :param a: Coefficient for flexibility, not indicitive (amplitude) :param b: Dampening coefficient :return: Function output. ''' return a * np.exp(b * x) # print(y_min) # Grabs the appropriate portion of the trace for the exponential fit for a paticular peak. ydata = search_area[:y_min[1]] xdata = [ydata.index(x) for x in ydata] # Performs the exponential fit. initial_guess = [-0.1, -0.1] popt, pcov = curve_fit(exp_func, xdata, ydata, initial_guess) # Calculates tau tau = -1 / popt[1] # Calculates r2 for exponential fit xFit = np.arange(0, len(ydata), 1) residuals = ydata - exp_func(xFit, *popt) ss_res = np.sum(residuals**2) ss_tot = np.sum((ydata - np.mean(ydata))**2) r2_decay = 1 - (ss_res / ss_tot) # Fitted model for getting AUC def func(x): return popt[0] * np.exp(popt[1] * x) # Calculates AUC auc = integrate.quad(func, 0, len(ydata))[0] # Plots the fit and decay if plot_me is true. if plot_me == True: plt.plot(xdata, ydata, 'b-', label='Peak Data') plt.plot(xFit, exp_func(xFit, *popt), 'g--', label='Fitted Curve') plt.title(peak_xt) plt.legend() plt.show() return tau, r2_decay, auc, perc
def fit2gauss(lam, y, yerr, min_tot=100.0, chi_thr=10.0, base=0.0, fit_indy=False, verbose=False): # min_tot = minimum intensity to try # chi_thr = Chi^2 threshold # base = base level subtracted when computing moments # fit_indy = option to truncate data array pre/post 0th moment calculation # ==== compute moments d = dict() yt = (y - base) #> 0.0 # a truncated version for moments if fit_indy == True: m0 = np.sum(yt) #> 1.0 # prevent problems with division m0 = np.maximum(m0, 1.0) yt[yt < 0.0] = 0.0 else: yt[yt < 0.0] = 0.0 # Dana's does this first. m0 = np.sum(yt) #> 1.0 # prevent problems with division m0 = np.maximum(m0, 1.0) m1 = np.sum(yt * lam) / m0 m2 = np.sum(yt * (lam - m1)**2) / m0 m3 = np.sum(yt * (lam - m1)**3) / m0 moms = [m0, m1, m2] # pack for return # if first moment is too small (nothing to fit) if (m0 < min_tot): #print('m0 = ',m0) chi1g = -1.0 a1g = [1.0, 1402.77, 1.0] a2g = [1.0, 1402.77, 1.0, 1.0, 1402.77, 1.0] d['moms'] = moms d['chi1g'] = chi1g d['chi2g'] = 100000 d['a2g'] = a2g d['a1g'] = a1g y1g = single_gauss_func_noder(lam, *a1g) pars_1 = a2g[0:3] pars_2 = a2g[3:6] y2a = single_gauss_func_noder(lam, *pars_1) y2b = single_gauss_func_noder(lam, *pars_2) d['y1g'] = y1g d['y2a'] = y2a d['y2b'] = y2b if verbose == True: print('Nothing to fit.. ejecting!') return d # ===== do 1-Gaussian fit # estimate parameters for 1-Gaussian fit sd = np.sqrt(m2) dx = lam[1] - lam[0] a0 = [dx * m0 / (np.sqrt(2 * np.pi) * sd), m1, sd] # estimate of 1-gaussian paramters # perform fit a1g, a1cov = curve_fit(single_gauss_func_noder, lam, y, p0=a0, maxfev=110000) #, bounds=(0, np.inf)) y1g = single_gauss_func_noder(lam, *a1g) #calculate chi_square y_modelone = single_gauss_func_noder(lam, *a1g) X2one = np.sum(((y_modelone - y) / yerr)**2) chi1g = X2one / (len(y) - 3) # reduced chi^2 # ==== do double-Gaussian fit # estimate parameters a0_2 = est_params([m0, m1, m2, m3], dx=dx) if verbose == True: print('est params = ', a0_2) # ========================================================================== # new routine to find peaks for initial parameters (not really ever used) ------------------------------- #spec_sm = savgol_filter(y, 3, 1) #smooth to make local peak finding more accurate peaks, _ = find_peaks(y) pos_peaks = lam[peaks] spec_peaks = y[peaks] iis = np.where(spec_peaks > 0.2 * np.max(y)) iis = iis[0] if (len(iis) > 2) and (verbose == True): print('!!!! - more than two peaks found') # as a precaution if len( iis ) < 2: # redo fitering to see if we can't get two peaks. if not, we'll call it a single gaussian. if verbose == True: print('single peak found') spec_sm = savgol_filter(y, 3, 1) #15->3? peaks, _ = find_peaks(spec_sm) pos_peaks = lam[peaks] spec_peaks = spec_sm[peaks] iis = np.where(spec_peaks > 0.05 * np.max(spec_sm)) iis = iis[0] if len( iis ) == 1: # then two peaks not found via find_peaks(). create artificial peak for fit process. if verbose == True: print('only one peak still') spec_val = 0.5 * np.max(spec_sm) spec_peaks = np.append(spec_peaks, spec_val) spec_pos = pos_peaks[iis] + 0.25 pos_peaks = np.append(pos_peaks, spec_pos) iis = np.append( iis, iis[-1] + 1) # add one more index for fitting purposes (need two). amp_peaks = spec_peaks[iis] # amplitude and position of peaks pos_peaks = pos_peaks[iis] # update exsisting estimation for fit parameters #a0_2[0],a0_2[1],a0_2[3],a0_2[4] = amp_peaks[0],pos_peaks[0],amp_peaks[1],pos_peaks[1] # ------------------------------------------------------------------------------------------ # ========================================================================== #if verbose==True: print('new init params = ', a0_2) upper_bound = [np.inf, 1404, np.inf, np.inf, 1404, np.inf] lower_bound = [500, 1402, 0, 500, 0, 0] a2g, a2cov = curve_fit(double_gauss_func_noder, lam, y, p0=a0_2, maxfev=110000, absolute_sigma=True) # individual gaussians of double fit pars_1 = a2g[0:3] pars_2 = a2g[3:6] y2a = single_gauss_func_noder(lam, *pars_1) y2b = single_gauss_func_noder(lam, *pars_2) # calculate chi^2 #y_modeltwo = double_gauss_func_noder(lam_s, *a2g) y2g = y2a + y2b y_modeltwo = y2g X2two = np.sum(((y_modeltwo - y) / yerr)**2) chi2g = X2two / (len(y) - 6) # reduced chi^2 if verbose == True: print('a2g =', a2g) print('a1g[0] =', a1g[0]) print('chi2g = ', chi2g) # method for selecting single aussian over double gaussian # if double fitting WORSE than single gaussian fit, OR OR OR if the amplitude of the second Gaussian is neglible small_amp = np.minimum(a2g[0], a2g[3]) lrg_amp = np.maximum(a2g[0], a2g[3]) lrg_vel = np.maximum(np.abs(a2g[1]), np.abs(a2g[4])) #if(chi1g<chi2g) or (small_amp<100) or (lrg_amp<100) or (chi1g<chi_thr) : #if (small_amp<0.1*lrg_amp) or (lrg_amp<0.1*small_amp) or (chi1g<chi_thr) : if (small_amp < 100) or (lrg_amp < 100) or (chi1g < chi_thr): a2g = np.concatenate((a1g, a1g)) # return copies of single fit params a2g[3] = 0.0 # but zero amplitude y2a = y1g y2b = 0.0 * y1g chi2g = -1.0 # flag that no fit was attmepted if verbose == True: print('a2g = ', a2g) print('chi1g = ', chi1g) print('chi2g = ', chi2g) d['moms'] = moms d['a1g'] = a1g d['y1g'] = y1g d['a2g'] = a2g d['y2a'] = y2a d['y2b'] = y2b d['chi2g'] = chi2g d['chi1g'] = chi1g return d
# plot the projection of the rotated cropped image f1_ax5 = fig.add_subplot(gs[2, 0]) print('--> fitting the projections') min_fit = 0 # define x array: should be kept as 0 since it's to get an array lenght only xd = np.arange(min_fit, min_fit + len(proj[0][min_fit:])) edge = np.zeros(evt_data) # plot the data plt.plot(xd, proj[show][min_fit:]) # execute the fit on the right part of the data for i in xrange(evt_data): popt, pcov = curve_fit( error_function, xd, proj[i][min_fit:]) #, bounds=([0, 0, 0, -10000], [5, 10, 1000, 0])) print(popt) edge[i] = popt[2] print(i, edge[i]) # plot the fit and the center extracted from the fit a t a 'show' position if i == show: plt.plot(xd, error_function(xd, popt[0], popt[1], popt[2], popt[3])) plt.axvline(x=popt[2]) # plot the histogram of the edge position print('--> plotting the histogram of the edge position') # normalise to get the gaussian properly fitting with the sum under the guassian = 1 f1_ax6 = fig.add_subplot(gs[2, 1]) n, bins, patches = plt.hist(edge,
def residuals(composition, color='grey', norm=7.0, overplot=False): dbase = ['Bacteria', 'Bacteria_draft', 'ResFinder', 'HumanMicrobiome', 'Plasmid', 'Virus', 'Unmapped', 'Plant', 'Invertebrates', 'Mitochondrion', 'Vertebrates_mammals', 'Vertebrates_other', 'Human'] for f in [0, 2]: fig = plt.figure(59+f) if not overplot: plt.clf() sns.set(style="darkgrid") sns.set(font_scale=1.05) # Vector components are [x_pos, y_pos, width, height] axt = [0.12, 0.84, 0.84, 0.13] axm = [0.12, 0.10, 0.84, 0.72] axis = ( fig.add_axes(axt, frame_on=True), fig.add_axes(axm, frame_on=True)) axis[0].set_yticks([]) axis[0].set_ylim(-.5, .5) axis[0].set_xlim(5.6, 8.3) axis[1].set_xlim(5.6, 8.3) axis[1].set_xlabel('Log(Total reads)') axis[1].set_ylabel('Log(Reads)') dat_x = np.log10(composition.sum()) # loc['notPhiX']) if f == 0: dat_y = np.log10(composition.loc['Bacteria_agg']) # +composition.loc['Bacteria_draft']) else: dat_y = np.log10(composition.loc[dbase[f]]) mean_x = np.mean(dat_x) mean_y = np.mean(dat_y) xvar = np.array([min(dat_x), max(dat_x)]) popt, pcov = so.curve_fit(gfunc.line, dat_x, dat_y) gplots.plot_fits(gfunc.line, axis[1], xvar, popt, pcov, color=color) bin_width = 2.*ss.iqr(dat_x)/pow(len(dat_x), 1./3.) - 0.03 nbins = int(np.ceil((max(dat_x)-min(dat_x))/bin_width)) qua1 = [] qua3 = [] mi = [] ma = [] for i in range(nbins): subset = [idx for idx, j in enumerate(dat_x) if j > ( min(dat_x)+i*bin_width) and j <= (min(dat_x)+(i+1)*bin_width)] mdn = np.median(dat_y[subset]-dat_x[subset]+mean_x-mean_y) if len(subset) > 1: qua1.append(np.median([k for k in dat_y[subset] - dat_x[subset]+mean_x-mean_y if k < mdn])) qua3.append(np.median([k for k in dat_y[subset] - dat_x[subset]+mean_x-mean_y if k > mdn])) else: qua1.append(0) qua3.append(0) mi.append(-np.min(dat_y[subset]-dat_x[subset]+mean_x-mean_y)) ma.append(np.max(dat_y[subset]-dat_x[subset]+mean_x-mean_y)) bins = np.linspace(min(dat_x), max(dat_x), nbins) xvar = np.linspace(min(dat_x), max(dat_x), 500) spl1 = ip.interp1d(bins, qua1, kind='cubic') spl2 = ip.interp1d(bins, qua3, kind='cubic') axis[1].scatter(dat_x, dat_y, alpha=0.7, s=15, color=color) axis[1].plot(xvar, (xvar-mean_x)+mean_y, '--', color='black', lw=2, alpha=0.5) axis[0].errorbar(bins, np.zeros(len(bins)), yerr=[mi, ma], alpha=0.7, capsize=4., capthick=2.0, markersize=6., markeredgewidth=0.5, fmt='') axis[0].plot(xvar, spl1(xvar), color=color) axis[0].plot(xvar, spl2(xvar), color=color) axis[0].fill_between(xvar, spl1(xvar), spl2(xvar), color=color, alpha=0.4) axis[0].plot([min(xvar), max(xvar)], [0, 0], '--', color='black') for i, name in enumerate(composition.columns): axis[1].annotate(name, (dat_x[i], dat_y[i])) # axis[1].annotate() if not overplot: axis[1].annotate(dbase[f], (6.1, axis[1].get_ylim()[1] - .1*(axis[1].get_ylim()[1] - axis[1].get_ylim()[0])))
# calculate Creutz ratio chi[r], d_chi[r] = jackknife_creutz(w00, w01, w11, 20) print("chi(%d,%d) = %.12f (%.12f)" % (r+1, r+1, chi[r], d_chi[r])) cursor.close() con.close() # best fit for string tension print("\nFitting string tension and plotting...") def sigma_fit(R, sqrt_sigma, B): return sqrt_sigma**2.0 + B / R**2.0 # return sqrt_sigma**2 + B * (1 / R**2 + 1 / (L - R)**2) # return sqrt_sigma**2 + B * (L / (R * (L - R)))**2 popt, pcov = opt.curve_fit(sigma_fit, R[R_min-1:R_max], chi[R_min-1:R_max], [0.05, 1.0], sigma=d_chi[R_min-1:R_max]) sqrt_sigma = popt[0] d_sqrt_sigma = np.sqrt(pcov[0][0]) B = popt[1] d_B = np.sqrt(pcov[1][1]) print("\nchi(R,R) = sigma + B / R^2") print("B = %.12f (%.12f)" % (B, d_B)) print("sigma = %.12f (%.12f)" % (sqrt_sigma**2, 2 * np.abs(sqrt_sigma) * d_sqrt_sigma)) print("sqrt(sigma) = %.12f (%.12f)" % (np.abs(sqrt_sigma), d_sqrt_sigma)) # calculate best fit curves R_A = np.linspace(0.001, R_half, 1000) _R2_A = np.zeros(len(R_A)) chi_A = np.zeros(len(R_A)) for r in range(0, len(R_A)): chi_A[r] = sigma_fit(R_A[r], sqrt_sigma, B)
def fit_the_values(country_, y_values , total_days, graph, output): """ We are going to fit the values """ try: base_value = y_values[0] # some preperations number_of_y_values = len(y_values) global TOTAL_DAYS_IN_GRAPH TOTAL_DAYS_IN_GRAPH = total_days # number of total days x_values = np.linspace(start=0, stop=number_of_y_values - 1, num=number_of_y_values) x_values_extra = np.linspace( start=0, stop=TOTAL_DAYS_IN_GRAPH - 1, num=TOTAL_DAYS_IN_GRAPH ) popt_d, pcov_d = curve_fit( f=derivate, xdata=x_values, ydata=y_values, #p0=[0, 0, 0], p0 = [26660, 9, 0.03, base_value], # IC BEDDEN MAART APRIL bounds=(-np.inf, np.inf), maxfev=10000, ) residuals = y_values - derivate(x_values, *popt_d) ss_res = np.sum(residuals**2) ss_tot = np.sum((y_values - np.mean(y_values))**2) r_squared = round( 1 - (ss_res / ss_tot),4) l = (f"polynome fit: a=%5.3f, b=%5.3f, c=%5.3f, d=%5.3f / r2 = {r_squared}" % tuple(popt_d)) a,b,c,d = popt_d deriv_0 = derivate(0, a,b,c,d) deriv_last = derivate(number_of_y_values,a,b,c,d) r_0_last_formula = (deriv_last/deriv_0)**(4/number_of_y_values) #r_0_last_cases = (y_values[number_of_y_values-1]/ y_values[0])**(4/number_of_y_values) r_total = sum( (derivate(i, a, b, c, d) / derivate(i - 1, a, b, c, d)) ** (4 / 1) for i in range(number_of_y_values - 5, number_of_y_values) ) #r_avg_formula = r_total/(number_of_y_values-1) r_avg_formula = r_total/6 r_cases_list = [] if output == True: #st.write (f"{country_} : {x_values} / {y_values}/ base {base_value} / a {a} / b {b} / c {c} / d {d} / r2 {r_squared}") st.write (f"{country_} : / base {base_value} / a {a} / b {b} / c {c} / d {d} / r2 {r_squared}") #st.write (f"Number of Y values {number_of_y_values}") #st.write (f"Number of R-values {len(r_cases_list)}") st.write (f"R from average values from formula day by day {r_avg_formula} (purple)") #st.write (f"R from average values from cases day by day {r_cases_avg} (yellow)") st.write (f"R getal from formula from day 0 to day {number_of_y_values}: {r_0_last_formula} (red)") #st.write (f"R getal from cases from day 0 to day {number_of_y_values}: {r_0_last_cases} (orange)") if graph == True: with _lock: fig1x = plt.figure() plt.plot( x_values_extra, derivate(x_values_extra, *popt_d), "g-", label=l ) plt.plot( x_values, cases_from_r(x_values, r_0_last_formula,deriv_0), "r-", label=(f"cases_from_r_0_last_formula ({round(r_0_last_formula,2)})") ) # plt.plot( # x_values, # cases_from_r(x_values, r_0_last_cases,deriv_0), # "orange", # label=(f"cases_from_r_0_last_cases ({round(r_0_last_cases,2)})") # ) plt.plot( x_values, cases_from_r(x_values, r_avg_formula,deriv_0), "purple", label=(f"cases_from_r_avg_formula ({round(r_avg_formula,2)})") ) # plt.plot( # x_values, # cases_from_r(x_values, r_cases_avg,deriv_0), # "yellow", # label=(f"cases_from_r_avg_cases ({round(r_cases_avg,2)})") # ) plt.scatter(x_values, y_values, s=20, color="#00b3b3", label="Data") plt.legend() plt.title(f"{country_} / curve_fit (scipy)") #plt.ylim(bottom=0) plt.xlabel(f"Days from {from_}") st.pyplot(fig1x) except RuntimeError as e: #str_e = str(e) #st.info(f"Could not find derivate fit :\n{str_e}") pass try: a = 1* r_avg_formula except NameError: r_avg_formula = None return r_avg_formula
#psi0=np.array([0+1j*0.0,1.0+1j*0.0,0.0+1j*0.0]) def constrainedPropagateHam(k, epsilon, U, n, S, m0): return lambda t, omega, delta: np.array( propagateRLHamiltonian2( t, k, omega, delta, epsilon, U, n, S, m0, rampOnt=rampOnt)) HofT = constrainedPropagateHam(k, epsilon, U, n, S, m0) ##print H(1.0,4.0,0.0,0.0) #a=np.array(tRecoils) #b=np.array(frac0) popt, pcov = optimize.curve_fit(HofT, tRecoils[:maxInd], fractions.flatten(), p0=(omegaGuess, deltaGuess)) print popt, np.sqrt(np.diag(pcov)) #popt=(0.6,0.08) tForFit = np.linspace(np.min(tRecoils), np.max(tRecoils), 100) pops_fitted = HofT(tForFit, *popt) #sort=np.argsort(tRecoils) #tSorted=tRecoils[sort] pops_fitted = pops_fitted.reshape(tForFit.size, 2 * S + 1).transpose() figure = plt.figure() panel = figure.add_subplot(1, 1, 1) panel.set_title(r'$\Omega$ = ' + str(np.round(popt[0], 2)) + r' $E_L/h$,$\delta$ = ' + str(np.round(popt[1], 3)) + r' $E_L/h$') #, U= '+str(np.round(popt[2],3))+r'$E_L$')
global NTs NTs = ([BOrd, BOrd + ROrd]) pT = np.zeros(BOrd + ROrd) #Have a run index after which temperature rises tendCut = 3570 tstartCut = 170 #Find that index in the data arrays place = np.where(runsTemp == tendCut)[0] print(runsTemp) #Keep only data before the cutoff index pT[BOrd] = np.mean(tempsTemp[tstartCut:place[0]]) #Stack the runs and B data so that it can be passed as one variable to the fit function RandB = np.vstack((runsTemp[tstartCut:place[0]], BsTemp[tstartCut:place[0]])).T #Call the fit function, this syntax is terrible but works. lambda essentially #defines a new function that we can pass as our fit function popt, pcov = curve_fit(lambda RandB, *pT: wrapT(RandB, *pT), RandB, tempsTemp[tstartCut:place[0]], p0=pT) #if you want to see fit results for temperature, uncomment here # print(popt) # print(popt/np.sqrt(np.diag(pcov #In order to get the true temperature, we need to subtract off the magnetic #field part. So define a parameter array where the run-dependent fit parts are 0 #and the magnetic field dependent parts are the results of the fit pSub = np.zeros(len(pT)) pSub[:BOrd] = popt[:BOrd] for h in range(0, len(fname)): Fdat1 = np.loadtxt(fname[h], delimiter="\t") F1 = np.loadtxt(f[h], delimiter="\t")
species_summary = [r] for m in methods: for l in losses: for b in constraints: # Some text to show what we're up to cons = constraint_labels[constraints.index(b)] notice = f"Attempting {SP} {m}/{l} {cons}" pad = 50 - len(notice) if __name__ == "__main__": print(f"{notice}{pad*' '}", end="") try: # we need to _try_ this so if it fails we can keep going fittedParameters, pcov = curve_fit(combinedFunction, comboX, comboY, bounds=b, method=m, loss=l) run_name = f"{SP} {m}_{l} {cons}" # Add a label # take the fitted parameters and associate them correctly forest_start, soil_start, B, phi_ab, k, v, phi_ba, phi_bs, phi_sa = ( fittedParameters) # re-run the growth model to get explicit results biomass_result = growth( x, forest_start, soil_start, B, phi_ab,
def k_effect_figures(fit=False): data_dirs = sorted(['data/'+pth for pth in next(os.walk("data/"))[1]]) df_all = [] for dpath in data_dirs: print('Loading ', dpath) try: with open(dpath+'/namespace.p', 'rb') as pfile: nsp=pickle.load(pfile) with open(dpath+'/synsrv_prb_equal.p', 'rb') as pfile: synsrv_prbs=np.array(pickle.load(pfile)) for synsrv in synsrv_prbs: concat = {**nsp, **synsrv} df_all.append(concat) except FileNotFoundError: print(dpath[-4:], "reports: No namespace or " +\ "synsrv_prb data. Skipping.") all_Npool = np.unique([df['Npool'] for df in df_all]) all_k = np.unique([df['k'] for df in df_all]) for npool in all_Npool: fig, ax = pl.subplots() fig.set_size_inches(5.2,3) for df in df_all: # if df['Npool']==npool and df['k'] in [7, 12, 17, 27]: if df['Npool']==npool and df['k'] in [10, 25, 100, 250, 1000]: label = "$k = "+str(df['k'])+"$" if fit: N = int(0.6*len(df['dts'])) prm, prm_cov = optimize.curve_fit(powerlaw_func_s, df['dts'][N:], df['synsrv_prb'][N:], p0=[0.5, 0.5]) xs = np.arange(df['dts'][0], df['dts'][-1], 1) bl, = ax.plot(xs, powerlaw_func_s(xs,*prm), linestyle='-', alpha=0.55) label = '$\gamma = %.4f$, s=%.3f \n' %(prm[0], prm[1]) + \ label + ', $N_{\mathrm{cut}} = %d$' %N ax.plot(df['dts'], df['synsrv_prb'], '.', # 'o', # markeredgewidth=1, # markerfacecolor='None', color=bl.get_color(), label=label) ax_ll = 0.9*df['dts'][1] else: print(df['synsrv_prb']) ax.plot(df['dts'], df['synsrv_prb'], '.', # 'o', # markeredgewidth=1, # markerfacecolor='None', label=label) ax_ll = 0.9*df['dts'][1] ax.spines['right'].set_visible(False) ax.spines['top'].set_visible(False) ax.yaxis.set_ticks_position('left') ax.xaxis.set_ticks_position('bottom') ax.set_xlabel('simulation steps') ax.set_ylabel('survival probability') # ---------------------------------------------- directory = 'figures/k_effect_equal_linear_tail-fit/' if not os.path.exists(directory): os.makedirs(directory) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) ax.legend(frameon=False, prop={'size': 7}, loc='center left', labelspacing=1.15, borderpad=1.25, bbox_to_anchor=(1, 0.5)) fname = "k_effect_Npool%d_linear" %(npool) fig.savefig(directory+'/'+fname+'.png', dpi=300, bbox_inches='tight') # ---------------------------------------------- directory = 'figures/k_effect_equal_tail-fit/' if not os.path.exists(directory): os.makedirs(directory) ax.set_xscale('log') ax.set_yscale('log') fname = "k_effect_Npool%d" %(npool) fig.savefig(directory+'/'+fname+'.png', dpi=300, bbox_inches='tight') # ---------------------------------------------- directory = 'figures/k_effect_equal_trimmed_tail-fit/' if not os.path.exists(directory): os.makedirs(directory) ax.set_xlim(left=ax_ll) fname = "k_effect_Npool%d_trimmed" %(npool) fig.savefig(directory+'/'+fname+'.png', dpi=300, bbox_inches='tight') pl.close(fig)
# because there std is also = 0, thus making the weight infinite v1 = df1.v mode = 0 if mode == 0: mask = (v1 < 3) & (v1 > -3) & (df1.f != 0) elif mode == 1: mask = (v1 < 3) & (v1 > 0) & (df1.f != 0) elif mode == -1: mask = (v1 < 0) & (v1 > -3) & (df1.f != 0) v1 = v1[mask] f1 = np.array(df1.f)[mask] err1 = np.array(df1.err)[mask] popt1, pcov1 = curve_fit(linear, v1, f1)#, sigma=err1, absolute_sigma=True) ax.plot(v1, linear(v1, *popt1), color="red", ls="-", label="Best fit") ax.plot(df1.v, linear(df1.v, slope, popt1[1]), color="blue", ls="--", label="Literature") ax.fill_between(df1.v, linear(df1.v, slope - slope_err, popt1[1]), linear(df1.v, slope + slope_err, popt1[1]), color="blue", alpha=0.35) ax.axvline(omega, color='orange', label="Lock-in freq.") ax.axvline(-omega, color='orange') ax.errorbar(df1.v, df1.f, yerr=df1.err, color="red", label="LabView Data", fmt='o', markeredgecolor="black", ecolor='black', capthick=2, capsize=2, elinewidth=1, markeredgewidth=0.5, ms=3) if mode == 0: d = {"v" : v1, "f1" : f1, "f1_err": err1
def main(): """Main function.""" # Create logger. log = logging.getLogger() # Load data simulate = False data = np.loadtxt(os.path.join('data', 'angleAndBeta_Bluejet_Redjet.txt')) data = data[data[:, 0].argsort()] date = data[:, 0] times = date - date[0] beta = data[:, 1] raw_values = beta values = beta - np.mean(beta) # Filter the data in various ways. limit_times = False remove_times = False remove_large_values = False if remove_large_values: std_ = np.std(values) print('STD:', std_) idx = np.logical_and(values < std_ * 2, values > -std_ * 2) times = times[idx] raw_values = raw_values[idx] values = values[idx] date = date[idx] if limit_times: # time_limit = [600, 2000] # time_limit = [600, 2000] time_limit = [900, 1600] idx_min = np.argmax(times >= time_limit[0]) idx_max = np.argmax(times >= time_limit[1]) if idx_max == 0: idx_max = times.size times = times[idx_min:idx_max] values = values[idx_min:idx_max] raw_values = raw_values[idx_min:idx_max] date = date[idx_min:idx_max] if remove_times: delete_range = [900, 1300] idx_min = np.argmax(times >= delete_range[0]) idx_max = np.argmax(times >= delete_range[1]) if idx_max == 0: idx_max = times.size() times = np.delete(times, range(idx_min, idx_max + 1)) values = np.delete(values, range(idx_min, idx_max + 1)) raw_values = np.delete(raw_values, range(idx_min, idx_max + 1)) date = np.delete(date, range(idx_min, idx_max + 1)) values -= np.mean(values) times -= times[0] # Simulate signal using time sampling from data set if simulate: sim_values = np.zeros_like(times) signals = [ dict(amp=0.03, freq=1 / 13.0865, phase=0.0), dict(amp=0.04, freq=1 / 11.2384, phase=0.0), # dict(amp=0.1, freq=0.0769, phase=0.0), ] log.debug('- Adding signals:') for i, s in enumerate(signals): log.debug(' [%02i] amp=%f, freq=%f, phase=%f', i, s['amp'], s['freq'], s['phase']) arg = (2 * math.pi * times * s['freq']) + (s['phase'] * math.pi) sim_values += s['amp'] * np.cos(arg) else: signals = None log.info('') min_frequency = 0 # IMPORTANT!!!!!!!! # CLEAN is *very* sensitive to the position of the peak with a horrible # PSF therefore with a poor PSF the spectrum oversample has to be very # large to not miss the peak position at all. # max_frequency = 0.2 # days^-1 freq_inc = 5e-6 # days^-1 freq_range = max_frequency - min_frequency num_freqs = math.ceil(freq_range / freq_inc) log.info('* No. (positive) frequencies = %i', num_freqs) if simulate: freqs, sim_amps, freqs_psf, sim_psf = dft(num_freqs, freq_inc, times, sim_values) sim_clean_components, sim_residual = clean(sim_amps, sim_psf, gain=0.1, num_iter=1000, freqs=freqs, f0=1 / 180) sim_clean_spectrum, sim_restored_spectrum = \ make_clean_spectrum(sim_psf, sim_clean_components, sim_residual) else: freqs, amps, freqs_psf, psf = dft(num_freqs, freq_inc, times, values) clean_components, residual = clean(amps, psf, gain=0.1, num_iter=1000, freqs=freqs, f0=1 / 180) clean_spectrum, restored_spectrum = \ make_clean_spectrum(psf, clean_components, residual) # Plotting amp_type = 'Beta' c = freqs.size // 2 fig, ax = plt.subplots(nrows=4, sharex=False, figsize=(10, 8)) fig.subplots_adjust(left=0.08, right=0.97, bottom=0.08, top=0.95, hspace=0.4, wspace=0.0) if simulate: plot_times(ax[0], times, sim_values, y_label=amp_type, title='Simulated signal', xlabel=r'\Delta Date [days]') plot_psf(ax[1], freqs_psf, sim_psf, title='PSF') plot_dirty(ax[2], freqs, sim_amps, signals, title='Dirty spectrum (simulated)') plot_clean_spectrum(ax[3], freqs, sim_restored_spectrum, sim_clean_spectrum, signals, signal_amps=True, title='CLEAN spectrum (simulated)') else: plot_times(ax[0], times, values, y_label=amp_type, title='Time series', xlabel='Date [days]') plot_psf(ax[1], freqs_psf, psf, title='PSF') plot_dirty(ax[2], freqs, amps, signals, title='Dirty spectrum.') plot_clean_spectrum(ax[3], freqs, residual, clean_spectrum, signals, signal_amps=False, title='CLEAN spectrum') # initial guess at fit parameters p0 = [0.0055, 0.076, 0.0006] p1 = [0.0085, 0.088, 0.0006] # p1 = [0.015, 0.0885, 0.0003] c = freqs.size // 2 full_search_range = True search_range = 10 try: if full_search_range: coeff0, _ = curve_fit(gauss, freqs[c:], np.abs(clean_spectrum[c:]), p0=p0) coeff1, _ = curve_fit(gauss, freqs[c:], np.abs(restored_spectrum[c:]), p0=p0) else: idx0 = np.argmax(freqs >= p0[1] - search_range * p0[2]) idx1 = np.argmax(freqs >= p0[1] + search_range * p0[2]) coeff0, _ = curve_fit(gauss, freqs[idx0:idx1 + 1], np.abs(clean_spectrum[idx0:idx1 + 1]), p0=p0) coeff1, _ = curve_fit(gauss, freqs[idx0:idx1 + 1], np.abs(restored_spectrum[idx0:idx1 + 1]), p0=p0) if abs(1 / coeff1[1] - 1 / p0[1]) < 2 and coeff1[2] / p0[2] < 4: if coeff1[0] > np.std(np.abs(restored_spectrum)) * 2: x_fit = np.linspace(coeff1[1] - search_range * coeff1[2], coeff1[1] + search_range * coeff1[2], 1000) delta_p = (1 / (coeff1[1] - coeff1[2]) - 1 / (coeff1[1] + coeff1[2])) peak_fit = gauss(x_fit, *coeff1) ax[3].plot(x_fit, peak_fit, 'r-', label=r'Fit: %.4f $\pm$ %.1f days' % (1 / coeff1[1], delta_p / 2)) elif abs(1 / coeff0[1] - 1 / p0[1]) < 2 and coeff0[2] / p0[2] < 10: if coeff0[0] > np.std(np.abs(restored_spectrum)) * 2: x_fit = np.linspace(coeff0[1] - 5 * coeff0[2], coeff0[1] + 5 * coeff0[2], 1000) peak_fit = gauss(x_fit, *coeff0) delta_p = (1 / (coeff0[1] - coeff0[2]) - 1 / (coeff0[1] + coeff0[2])) ax[3].plot(x_fit, peak_fit, 'r-', label=r'Fit: %.4f $\pm$ %.1f days' % (1 / coeff0[1], delta_p / 2)) except RuntimeError: pass try: if full_search_range: coeff2, _ = curve_fit(gauss, freqs[c:], np.abs(clean_spectrum[c:]), p0=p1) coeff3, _ = curve_fit(gauss, freqs[c:], np.abs(restored_spectrum[c:]), p0=p1) else: idx0 = np.argmax(freqs >= p1[1] - search_range * p1[2]) idx1 = np.argmax(freqs >= p1[1] + search_range * p1[2]) coeff2, _ = curve_fit(gauss, freqs[idx0:idx1 + 1], np.abs(clean_spectrum[idx0:idx1 + 1]), p0=p1) coeff3, _ = curve_fit(gauss, freqs[idx0:idx1 + 1], np.abs(restored_spectrum[idx0:idx1 + 1]), p0=p1) if abs(1 / coeff3[1] - 1 / p1[1]) < 2 and coeff3[2] / p1[2] < 10: x_fit = np.linspace(coeff3[1] - search_range * coeff3[2], coeff3[1] + search_range * coeff3[2], 1000) peak_fit = gauss(x_fit, *coeff3) delta_p = (1 / (coeff3[1] - coeff3[2]) - 1 / (coeff3[1] + coeff3[2])) ax[3].plot(x_fit, peak_fit, 'g-', label=r'Fit: %.4f $\pm$ %.1f days' % (1 / coeff3[1], delta_p / 2)) elif abs(1 / coeff2[1] - 1 / p1[1]) < 2 and coeff2[2] / p1[2] < 5: x_fit = np.linspace(coeff2[1] - 5 * coeff2[2], coeff2[1] + 5 * coeff2[2], 1000) peak_fit = gauss(x_fit, *coeff2) delta_p = (1 / (coeff2[1] - coeff2[2]) - 1 / (coeff2[1] + coeff2[2])) ax[3].plot(x_fit, peak_fit, 'g-', label=r'Fit: %.4f $\pm$ %.1f days' % (1 / coeff2[1], delta_p / 2)) except RuntimeError: pass ax[3].legend(loc='best', fontsize='small') amp_limit_str = '2std' if remove_large_values else 'all' if simulate: amp_type = 'simulated_%s' % amp_type if limit_times: plt.savefig('%s_times_%03.0f-%03.0f_amps_%s.png' % (amp_type, time_limit[0], time_limit[1], amp_limit_str)) else: plt.savefig('%s_times_all_amps_%s.png' % (amp_type, amp_limit_str)) plt.show() plt.close()
def plot_curve(self, pos, tit, path): max_degree = 3 fig = plt.figure() ax = plt.subplot(111) #ax = fig.add_axes([0.1, 0.2, 0.4, 0.4]) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.6, box.height]) maxX = 0 minX = 100000000 for n in xrange(self.number_table): if (self.graphList[n] != None): l = self.graphList[n].centrality[pos] if (min(l) < minX): minX = min(l) if (max(l) > maxX): maxX = max(l) nbin = 50 vec = [] vec.append(minX) val = minX step = float(maxX - minX) / float(nbin) for i in xrange(nbin - 1): val += step vec.append(val) vec.append(maxX) for n in xrange(self.number_table): if (self.graphList[n] != None): l = self.graphList[n].centrality[pos] #ax.hist(l, bins=np.arange(minX, maxX, 10)) hist, bins = np.histogram(l, bins=vec) width = 1 * (bins[1] - bins[0]) center = (bins[:-1] + bins[1:]) / 2 ax.bar(center, hist, align='center', alpha=0.4, width=width, color=colors[n]) x = np.array(center) y = np.array(hist) #print np.array(x) #print np.array(y) # m = dict((i,l.count(i)) for i in l) # y = np.array(m.values()) # x = np.array(m.keys()) # x = ar(range(10)) #gauss points # y = ar([0,1,2,3,4,5,4,3,2,1]) x_new = np.linspace(x[0], x[-1], num=len(x) * 10) #ploynomial fit best = 0 min_ = float('inf') i = 0 while (i <= max_degree): coefs, val = poly.polyfit(x, y, i, full=True) #print str(i) + " *" + str(val[0])+"*" if (val[0] < 1e-15 and min_ != 0): best = i method = 1 min_ = 0 if (len(val[0]) == 0 and min_ != 0): best = i method = 1 min_ = 0 elif (val[0] < min_ and coefs[0] != 0): best = i method = 1 min_ = val[0] i += 1 #print "rect" + str(min_) # power law try: popt, pcov = curve_fit(power_law, x, y, maxfev=1000000) residuals = y - power_law(x, *popt) fres = sum((residuals)**2) if (fres < min_): method = 2 min_ = fres except Exception as e: print "No power-law: " + str(e) #print "pl " + str(fres) try: # exponential popt1, pcov = curve_fit(exponential, x, y, maxfev=1000000) residuals = y - exponential(x, *popt1) fres = sum((residuals)**2) if (fres < min_): method = 3 min_ = fres except: print "no expopential" #print "exp " + str(fres) #gaussian try: len_ = len(x) #the number of data mean = sum(x * y) / len_ #note this correction sigma = sum(y * (x - mean)**2) / len_ popt2, pcov = curve_fit(gauss_function, x, y, maxfev=1000000) residuals = y - gauss_function(x, *popt2) fres = sum((residuals)**2) if (fres < min_): method = 4 #print fres #print min_ #print(fres < min_) except: print "no gaussian" #print "gaus " + str(fres) #hist, bins = ax.hist(x) #ax.plot(x, y, colors[n]+ 'o', label= self.graphList[n].name +" data") #print "meth: " + str(method) if (method == 1): coefs = poly.polyfit(x, y, best) coefs = coefs[::-1] f = np.poly1d(coefs) ax.plot(x_new, f(x_new), colors[n], label=self.graphList[n].name + "\n" + func_print(method, coefs)) elif (method == 2): ax.plot(x_new, power_law(x_new, *popt), colors[n], label=self.graphList[n].name + "\n" + func_print(method, popt)) elif (method == 3): ax.plot(x_new, exponential(x_new, *popt1), colors[n], label=self.graphList[n].name + "\n" + func_print(method, popt1)) elif (method == 4): ax.plot(x_new, gauss_function(x_new, *popt2), colors[n], label=self.graphList[n].name + "\n" + func_print(method, popt2)) print method ax.set_xlabel('Value') ax.set_ylabel('Frequency') # box = ax.get_position() # ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) # ax.legend(loc='center left', bbox_to_anchor=(1, 1)) #ax.axis([-0.05, 1.05, -0.05, 1.05]) #ax.legend(loc='center left', bbox_to_anchor=(0.78, 0.95), prop={'size':9}) ax.legend(loc='center left', bbox_to_anchor=(1.05, 0.60), prop={'size': 10}) #ax.legend() plt.title(tit) plt.savefig(path + ".png", format='png', dpi=400) return plt
def fit(self): if self.data is None: return None self.update_data() xl = int(self.get_channel('A', int(self.input_a0.text()))) xr = int(self.get_channel('A', int(self.input_a1.text()))) if xl < self.ch_range[0]: xl = self.ch_range[0] if xr >= self.ch_range[1]: xr = self.ch_range[1] - 1 yl = int(self.get_channel('B', int(self.input_a0.text()))) yr = int(self.get_channel('B', int(self.input_a1.text()))) if yl < self.ch_range[0]: yl = self.ch_range[0] if yr >= self.ch_range[1]: yr = self.ch_range[1] - 1 df = pandas.DataFrame(self.data, columns=['A', 'B']) good = df[df.A >= xl][df.A <= xr][df.B >= yl][df.B <= yr] if self.combo_fit.currentText() == 'A': bins, edges = numpy.histogram(good.A, range=self.ch_range, bins=self.ch_bins) col = 0 row = 1 elif self.combo_fit.currentText() == 'B': bins, edges = numpy.histogram(good.B, range=self.ch_range, bins=self.ch_bins) xl = yl xr = yr col = 1 row = 0 elif self.combo_fit.currentText() == 'dt': bins, edges = numpy.histogram(good.B - good.A, range=(-100, 100), bins=200) xl = 0 xr = 199 col = 0 row = 0 x0 = numpy.argmax(bins[xl:xr]) + edges[xl] s = (xr - xl) / 3 a1 = (bins[xr] - bins[xl]) / (edges[xr] - edges[xl]) a0 = bins[xl] - edges[xl] * a1 A = (sum(bins[xl:xr]) - a1 / 2 * (edges[xr]**2 - edges[xl]**2) - a0 * (edges[xr] - edges[xl])) try: popt, pcov = curve_fit(self.peak, edges[xl:xr], bins[xl:xr], p0=[A, x0, s, a1, a0]) except RuntimeError: self.input_fit.setPlainText('Fit error') return None self.axes[col][row].plot( edges[xl:xr] * self.calib[self.combo_fit.currentText()][1] + self.calib[self.combo_fit.currentText()][0], self.peak(edges[xl:xr], *popt), '--') perr = numpy.sqrt(numpy.diag(pcov)) params = ['A', 'x0', 's', 'a0', 'a1'] text = '' for i in [1, 2]: text += '{} = {:.1f} +/- {:.2f}\n'.format( params[i], popt[i] * self.calib[self.combo_fit.currentText()][1] + self.calib[self.combo_fit.currentText()][0], perr[i] * self.calib[self.combo_fit.currentText()][1] + self.calib[self.combo_fit.currentText()][0]) self.input_fit.setPlainText(text) for i in [0, 3, 4]: text += '{} = {:.1f} +/- {:.2f}\n'.format(params[i], popt[i], perr[i]) self.input_fit.setPlainText(text) self.figure.canvas.draw() self.figure.canvas.flush_events()
def fit(xs, ys): def f(x, a, b): return a * x + b params, _ = optimize.curve_fit(f, xs, ys) return params
set_dir = ["8xset1/", "8xset2/", "8xset3/"] compsum = 0 for i in set_dir: comp1 = np.loadtxt(i + 'out_125_1000.txt') comp2 = np.loadtxt(i + 'out_1000_8000.txt') comp3 = np.loadtxt(i + 'out_8000_64000.txt') compsum += comp1 + comp2 + comp3 np.savetxt("compsum_mono_raw.txt", compsum, fmt="%d") compsum[compsum > 255] = 255 sum = Image.fromarray(np.uint8(compsum, mode='L')) sum.save('compsum_mono.jpg') compsum_loaded = np.loadtxt('compsum_mono_raw.txt') fit, x = bin_count(np.flip(compsum_loaded, 0), 'mono') print(fit) x_data = (x + 0.5) / 256. y_data = (fit + 0.5) / 256. plt.plot(x_data, y_data) popt, pcov = curve_fit(func, x_data, y_data, maxfev=1000) plt.plot(x_data, func(x_data, *popt), 'r-', label='fit: a=%5.3f, c=%5.3f' % tuple(popt)) plt.legend() plt.savefig('result/fit_curve_mono.png') plt.clf()
#get an initial guess for the fit by simply taking the maximum value of the peak monitor3_height_guess = np.max(monitor_a_intensity) print("monitor3_height_guess", monitor3_height_guess) monitor3_peakcenter_guess = monitor_a_tof[np.argmax(monitor_a_intensity)] print("monitor3_peakcenter_guess", monitor3_peakcenter_guess) monitor3_sigma_guess = 50 print("monitor3_sigma_guess", monitor3_sigma_guess) #fit_result = Fit(Function='name=Gaussian,Height='+str(monitor3_height_guess)+',PeakCentre='+str(monitor3_peakcenter_guess)+',Sigma='+str(monitor3_sigma_guess), InputWorkspace=monitor_a, Output=monitor_a, OutputCompositeMembers=True) #def gaussian_s_b mu, sig, scale, background initial_guess = (monitor3_peakcenter_guess, monitor3_sigma_guess, monitor3_height_guess, 1.) popt, pcov = opt.curve_fit(gaussian_s_b, monitor_a_tof_centered, monitor_a_intensity, p0=initial_guess) popt_names = ['mu', 'sig', 'scale', 'background'] print("****************") print("results of gaussian_s_b fit to elastic line in TOF") for idx, i in enumerate(popt): print(popt_names[idx], i) print(initial_guess[idx]) data_fitted = gaussian_s_b(monitor_a_tof_centered, *popt) """ plt.figure() plt.plot(monitor_a_tof_centered, data_fitted) plt.plot(monitor_a_tof_centered, monitor_a_intensity) plt.plot(monitor_a_tof[:-1], monitor_a_intensity) plt.show()
from mpl_toolkits.mplot3d import Axes3D import numpy as np from scipy.optimize import curve_fit from matplotlib import pyplot as plt from matplotlib import cm def f(X, a,b): return (a/X) + b my_data = np.genfromtxt('results.txt', delimiter=',') param, param_cov = curve_fit(f, my_data[:,0], my_data[:,1]) ans = f(my_data[:,0], *param) total = param[0] + param[1] s = param[1]/total p = param[0]/total print('s', param[1]) print('p', param[0]) print('max speedup', 1/s) N = my_data[:,0] plt.plot(N, ans, '--', color ='red', label =("fit p={} s={}".format(param[0], param[1]))) plt.scatter(N, my_data[:,1], label='data') plt.legend() plt.xlabel('N proc') plt.ylabel('T [us]') plt.title('data fit t=s+p/N')
def fit_best(LC, p, maxNterms=5, output='compact', plotname=False): """ fit a lightcurve with a fourier model given period p input LC: 2D-array; [t,y,dy] p: float; the period output: array; model values for times t """ t = LC[:, 0] y = LC[:, 1] dy = LC[:, 2] N = np.size(t) if N <= 4 + maxNterms * 2: return np.nan * np.ones(4 + maxNterms * 2) # f = make_f(p=p) chi2 = np.zeros(maxNterms + 1, dtype=float) # fill in later Fstats = np.zeros(maxNterms + 1, dtype=float) # fill in later pars = np.zeros((maxNterms + 1, (maxNterms + 1) * 2)) # fill in later init = [16.0, 0.001] # the initial values for the minimiser for i, Nterms in enumerate(np.arange(maxNterms + 1., dtype=int)): # fit using scipy curvefit popt, pcov = curve_fit( make_f(p), # function t, y, # t,dy init, # initial values [1.0]*2 sigma=dy # dy ) init = init + [0.05] * 2 pars[i, :2 * (i + 1)] = popt # make the model model = f(t, *popt) chi2[i] = np.sum(((y - model) / dy)**2) # calc BICs BIC = chi2 + np.log(N) * (2 + 2 * np.arange(maxNterms + 1, dtype=float)) best = np.argmin(BIC) power = (chi2[0] - chi2[best]) / chi2[0] bestBIC = BIC[best] bestpars = pars[best, :] if plotname: for n in [0, 1]: plt.errorbar(t / p % 1 + n, y, dy, fmt='k.') plt.plot(t / p % 1 + n, f(t, *bestpars), 'r.') plt.ylim(plt.ylim()[::-1]) plt.savefig(plotname) plt.close() if output == 'compact': # convert to amplitude and phase if best > 0: bestpars[2:2 + 2 * best] = AB2AmpPhi(bestpars[2:2 + 2 * best]) return np.r_[power, bestBIC, bestpars]
def norm_fit(pres, arg): unitchange = 1 / 0.13332236842105 norm_pres = unitchange * pres norm_arg = (arg - min(arg)) / (max(arg) - min(arg)) popt, _ = curve_fit(func, norm_arg[1:], norm_pres[1:], maxfev=50000) return popt