def fitear(funcion_aux, x_data, y_data, params_opt=None): if params_opt: fit_params, fit_covar = fit(funcion_aux, x_data, y_data, p0=params_opt) else: fit_params, fit_covar = fit(funcion_aux, x_data, y_data) cant_param = len(fit_params) params = np.array([]) for ind_param in range(cant_param): params = np.append(params, fit_params[ind_param]) return funcion_aux(x_data, *params)
def fit(self, func, p0, freq_range=(0, 1.5), bounds=(-np.inf, np.inf)): self._func = func T = self.T.loc[self.T.freq.between(*freq_range)] real_func = lambda *args: np.real(func(*args)) imag_func = lambda *args: np.imag(func(*args)) ropt, rcov = fit(real_func, T.freq, T.real, p0=p0, bounds=bounds) iopt, icov = fit(imag_func, T.freq, T.imag, p0=p0, bounds=bounds) rerr = np.sqrt(np.diag(rcov)) ierr = np.sqrt(np.diag(icov)) return pd.DataFrame({'r': ropt, 'rerr': rerr, 'i': iopt, 'ierr': ierr})
def fit_data(data, ini, t=None): if t: func = lambda B, Hf, Hso: wl.delta_sigma(B, Hf, Hso, t) ini = ini[:2] else: func = wl.delta_sigma try: popt, pcov = fit(func, data.B, data.s, p0=ini) perr = np.sqrt(np.diag(pcov)) if t: popt.append(t) perr.append(0) out = dict(zip(['Hf', 'Hso', 't', 'Hf_err', 'Hso_err', 't_err'], np.concatenate((popt, perr)))) except: print('Could not find the optimal parameters for ', data.attrs) out = dict(zip(['Hf', 'Hso', 't', 'Hf_err', 'Hso_err', 't_err'], np.full(6, None))) finally: return out
def run(self, cxn, context): self.pulser.line_trigger_state(False) self.setup_datavault( 'frequency', 'photons') # gives the x and y names to Data Vault self.setup_grapher('Interleaved Linescan') self.detunings = self.get_scan_list( self.p.InterleavedLinescan.line_scan, 'MHz') return_detuning, return_counts = [], [] for i, detuning in enumerate(self.detunings): if context == (0, 2): should_break = self.update_progress(i / float(len(self.detunings))) if should_break: return should_break # self.p.Transitions.main_cooling_369 divide by 2 for the double pass freq = U(detuning, 'MHz') / 2.0 + self.p.ddsDefaults.DP369_freq track_detuning, track_counts = self.program_pulser(freq, detuning) return_detuning.append(track_detuning) return_counts.append(track_counts) # skip first couple points of data since they occasionally come in at random values # after performing a Shelving experiment, should not affect fit. Then set the parameter # in parametervault to the fitted center popt, pcov = fit(self.lorentzian_fit, return_detuning[2:], return_counts[2:], p0=self.fit_guess) self.pv.set_parameter( ('Transitions', 'main_cooling_369', U(popt[0], 'MHz')))
def run(self, cxn, context): self.set_default_parameters() self.setup_datavault('time', 'probability') self.setup_grapher('Rabi Flopping qubit_0') self.times = np.arange(0.1, 6.1 * self.pi_time, 3.2) probs, times = [], [] for i, duration in enumerate(self.times): should_break = self.update_progress(i/float(len(self.times))) if should_break: self.pulser.line_trigger_state(False) break self.p['MicrowaveInterrogation.duration'] = U(duration, 'us') self.program_pulser(sequence) [counts] = self.run_sequence() if i % self.p.StandardStateDetection.points_per_histogram == 0: hist = self.process_data(counts) self.plot_hist(hist) pop = self.get_pop(counts) self.dv.add(duration, pop) probs.append(pop) times.append(duration) popt, pcov = fit(self.rabi, times, probs, p0=[1.0, self.pi_time, 0.0, 0.0], bounds=(0.0, [1.0, 200.0, 3.14, 1.0])) self.pv.set_parameter(('Pi_times', 'qubit_0', U(popt[1], 'us'))) print('Updated qubit_0 pi_time to ' + str(popt[1])[:8] + ' microseconds') return popt[1]
def get_fit_inrange(binc, y, inf, sup, plot=False): entries = np.sum(y) x = binc[np.where((binc > inf) & (binc < sup))] y = y[np.where((binc > inf) & (binc < sup))] s = np.sqrt(y * (1 - y / entries)) mean = np.dot(y, x) / np.sum(y) std = 20 # np.std(data) A = np.max(y) par, cov = fit(gaus, x, y, p0=[A, mean, std, 0, 0], sigma=s, absolute_sigma=True) if plot: xfit = np.linspace(np.min(x), np.max(x), 500) ax.plot(x, y, '.b', label='Data') ax.plot(xfit, gaus(xfit, *par), 'r', label='Fit') ax.set_xlabel('ADC') ax.set_ylabel('Entries') ax.legend(loc=1, frameon=True, fancybox=False, framealpha=1, edgecolor='k') plt.draw() plt.pause(0.5) plt.cla() N = x.size return par, cov, N
def modelfit(N, bins, count, params): burst=PulseModel(N, bins, counts) final_param=fit(burst, bins, count, p0=param) return final_param
def runFit(self , simulated , experimental , a0 , d0 , shift0 , key): popt , pcov = fit(self.convolveWithGaussian , simulated, experimental, p0 = (a0 , d0 , shift0), bounds = ((0 , 0 , 0) , (10 , 10 ,1) )) broadened = self.convolveWithGaussian(simulated , *popt) print(key + ": fwhm= " , popt[0] , "+/- " , pcov[0][0] ," ", ", vertical shift= " , popt[1] , "+/- " , pcov[1][1] ," ", ", horizontal shift= " , popt[2] , "+/- " , pcov[2][2] ," ") return(broadened , popt , pcov)
def gauss(model, x, y, p0): popt, pcov = fit( model, x, y, p0) #popt son los parametros del fit, pcov es la curva del fit maxg = popt[0] meang = popt[1] sigmag = popt[2] return [maxg, meang, sigmag]
def shockley_fit(I, V): params = fit( shockley, V, I, ) n = params[0][0] Is = params[0][1] return [n, Is]
def Gaussfit( space, Array, init_width=30 ): # Fit Gaussian to magnitude of Amplitude array. Return fit parameters. init_params = [ 0.1, 1, init_width ] # Use initial width parameter smaller than expected width for beam profile. Otherwise, use initial width parameter larger than expected width - avoids bad fit in k-space. est_params, est_err = fit(Gaussian, space, Array, p0=init_params) return est_params # [offset, amplitude, width]
def MC_Amer_call(S0, K, mu, r, d, sigma, t, T, delta_t, N): ''' Parameters ========== S0: float Initial value of stock process mu: float Drift of stock process r: float Risk Free rate delta: float Continuous dividend yield sigma: float Volatility of stock process T: float Time horizon delta_t: float Time step size N: integer Number of paths to generate Returns ======= C: Float Value of American call option ''' M = int((T - t) / delta_t) # number of steps. Must be an integer. S = generate_paths(S0, mu, d, sigma, delta_t, N, M) h = np.maximum(S - K, 0) #compute exercise values g = h[M] #set up excercised value vector tau = np.repeat(T, N) #set up stopping time vector for j in range(M - 1, 0, -1): k = S[j] > K #in the money boolean vector x = S[j, k] # in the money points y = g[k] * np.exp(-(r - d) * (tau[k] - t * delta_t)) a, __ = fit(func, x, y) #regression step C_hat = func(S[j, k], a[0], a[1], a[2], a[3]) #find estimated continuation value g[k][C_hat >= h[j, k]] = h[j, k][ C_hat >= h[j, k]] #update g where excercise more than continuation tau[k][C_hat >= h[j, k]] = j / f8(M) * ( T - t) #update optimal excercise time C_0 = np.sum(np.exp(-(r - d) * delta_t * tau).T * g) / N V_0 = np.maximum(C_0, h[0, 0]) return V_0
def von_mises_fit(stimulusAng,avgSur=180): """The von Mises fit function: This function creates the best von Mises fit on the neuronal population activity by using Levenberg-Marquardt algorithm. The fit is done by using the fit_func(ang,amp,kappa,avg) outputs. scipy.optimize.curve_fit() is used for Levenberg-Marquardt algorithm. The decoded center hue angle is the angle (x value) of the von Mises fit with global maximum (maximal y-value). Paramters --------- stimulusAng: float. The hue angle of the center stimulus in degrees. avgSur: float, optional. The hue angle of the surround stimulus in degrees. Returns ------- popt[2]-stimulusAng: float. The angle difference between the decoded and real center stimulus hues stimulusAng-avgSur: float. The angle difference between the center and surround stimuli hues popFit: list. All x-values of the von Mises fit to the population activity for different center stimulus conditions. surDecoder: list. The ensemble of the population activity for different center stimulus conditions. popt: list. The von Mises fit parameter values. These values are amplitude,kappa and global maximum, respectively. """ #stimulusAng=180 surDecoder=[]#Population activity for a given center-surround stimulus for i in range(0,len(colMod.resulty)): surDecoder.append(colMod.resulty[i][np.where(colMod.x==stimulusAng)[0][0]]) x=colMod.x[np.where(colMod.x==0)[0][0]:np.where(colMod.x==360)[0][0]]#angles are restricted to a single cycle for the fit popt, pcov = fit(fit_func, colMod.unitTracker, surDecoder,method='lm')#Levenberg-Marquardt algorithm, popt is the fit parameters, pcov gives the covariance matrix. popFit=fit_func(x,*popt)#The fit values to the population activity """ Transform the negative angular values to the positive matching angle. """ if popt[2]>360: popt[2]=popt[2]-360 if popt[2]<-360: popt[2]=popt[2]+360 """ If the kappa is fit as a negative value, it can be changed to the positive by adding 180° to the maximum value of the fit. """ if popt[1]<0: popt[1]=abs(popt[1]) popt[2]=popt[2]+180 if popt[2]<-0.1 and popt[1]>0: popt[2]=360+popt[2] #THESE IF STATEMENTS are to solve the irregular parameters problem: due to the fact: cos(x)=cos(-x) and -a*cos(x)=acos(x+180), if kappa is negative it is changed #to its positive value before adding +180 to the readout angle. Similarly, if kappa is positive but angle is negative, 360 degrees are added (in that part threshold #is given as -0.1 because in the beginning (stimulus angle=0) there is small error that decoded angle is in -0.000001 range.) return popt[2]-stimulusAng, stimulusAng-avgSur, popFit,surDecoder, popt
def run(self, cxn, context): self.setup_datavault( 'frequency', 'probability') # gives the x and y names to Data Vault self.setup_grapher('Microwave Linescan qubit_minus') self.detunings = self.get_scan_list(self.p.MicrowaveLinescan.scan, 'kHz') self.set_default_parameters() deltas, probs = [], [] for i, detuning in enumerate(self.detunings): should_break = self.update_progress(i / float(len(self.detunings))) if should_break: break self.p['MicrowaveInterrogation.detuning'] = U(detuning, 'kHz') self.program_pulser(sequence) [counts] = self.run_sequence() if i % self.p.StandardStateDetection.points_per_histogram == 0: hist = self.process_data(counts) self.plot_hist(hist) pop = self.get_pop(counts) self.dv.add(detuning + self.p.Transitions.qubit_minus['kHz'], pop) deltas.append(detuning + self.p.Transitions.qubit_minus['kHz']) probs.append(pop) param_guess = [ 20.0, deltas[np.argmax(probs)], np.min(probs), np.max(probs) - np.min(probs) ] popt, pcov = fit(self.sinc_fit, deltas, probs, p0=param_guess) self.pv.set_parameter(('Transitions', 'qubit_minus', U(popt[1], 'kHz'))) print('Updated qubit_minus frequency to ' + str(popt[1]) + ' kHz') return should_break
def run_interleaved_linescan(self): self.pulser.line_trigger_state(False) linescan_context = self.sc.context() self.line_tracker = self.make_experiment(interleaved_linescan) self.line_tracker.initialize(self.cxn, linescan_context, self.ident) try: detunings, counts = self.line_tracker.run(self.cxn, linescan_context) except TypeError: return TypeError if max(counts) < 100: print("Lorentzian is weak or missing") return RuntimeError if self.p.MicrowaveInterrogation.AC_line_trigger == 'On': self.pulser.line_trigger_state(True) self.pulser.line_trigger_duration( self.p.MicrowaveInterrogation.delay_from_line_trigger) fit_guess = [5.0, 30.0, 4000.0, 1.0] try: popt, pcov = fit(self.lorentzian_fit, detunings[2:], counts[2:], p0=fit_guess) except RuntimeError: print( 'Fit did not work, returning RuntimeError from scipy.curve_fit' ) return RuntimeError center = popt[0] return center
phi = -data[3]*f * 360 # phase = deltaT/T * 360 fig = bodeplot(f, Amp=Vout/Vin, Phase=phi, deg=True) # Model fline = np.logspace(0, log10(2000), 1000) Hline = H_teo(2*np.pi*fline) Hline_abs = np.absolute(Hline) Hline_phase = np.angle(Hline) * 180/np.pi fig = bodeplot(fline, Amp=Hline_abs, Phase=Hline_phase, figure=fig, asline=True) # Slope estimation x = f[-3:] y = 20*np.log10(Vout[-3:]/Vin[-3:]) M = np.ones((y.size, 2)) M[:,1] = y params = fit(lambda x,p1,p2: p1+np.log10(x)*p2, x, y) print("Slope [dB/decade]", params[0][0]) xline = np.linspace(6e1, max(x), 1000) # plot stile ax = fig.axes[0] handles,_ = ax.get_legend_handles_labels() fig.legend(handles, labels=["Data", "Model"], loc ='lower center', ncol=2) fig.subplots_adjust(hspace=0.4, left=0.1) ax.plot(xline, params[0][0] + params[0][1]*np.log10(xline), '--') plt.plot() plt.tight_layout() plt.show() # Output impedance fig = bodeplot(fline, Amp=np.absolute(Z_osc(2*np.pi*fline)), Phase=np.angle(Z_osc(2*np.pi*fline)), asline=True)
import numpy as np from scipy.optimize import curve_fit as fit z = [ 0.07, 0.11, 0.14, 0.18, 0.22, 0.27, 0.31, 0.36, 0.4, 0.45, 0.5, 0.55, 0.61, 0.66, 0.72, 0.82, 0.98, 1.15, 1.33, 1.53, 1.75, 1.98, 2.24, 2.52, 2.82, 3.15 ] a = [] for i in z: a.append(1.0 / i) te = [ 2.51, 1.47, 1.52, 1.93, 2.07, 0.69, 1.4, 0.79, 1.92, 1.33, 1.15, 1.56, 0.77, 1.16, 1.26, 0.91, 0.31, 1.55, 0.61, 0.37, 0.42, 0.54, 0.17, 0.18, 0.27, 0.32 ] t = [] for tmp in te: t.append(tmp * 10**6) #plt.scatter(a,t) def func(x, a, b, k): return a * np.log10(b * x) + k popt, pcov = fit(func, a, t) plt.plot(a, func(a, *popt))
with open("C1t2mgh2ogood00000.txt", 'r') as file: for line in file.readlines()[23000::10]: #Drop data points before waveform begins. Downsample by 10. time, amplitude = line.split(',') times.append(float(time)) amplitudes.append(float(amplitude)) times = np.asarray(times) amplitudes = np.asarray(amplitudes) peaks, properties = find_peaks(amplitudes, height=exponential(times, 5.65, 1/0.04, 0.5), distance=1000) #Fit data. Write data and fit to a file. fit_params, fit_error = fit(exponential, times[peaks], amplitudes[peaks], p0=(6.5, 20, 1)) errors = np.divide(np.sqrt(np.diag(fit_error))*100, fit_params) print("Model: " + str(fit_params[0]) + '*E^(-x/' + str(1/fit_params[1]) + ") + " + str(fit_params[2])) plt.title("MG spin-echo measurement for heavy mineral oil") plt.xlabel("Time (s)") plt.ylabel("Amplitude (V)") plt.plot(times, amplitudes) plt.scatter(times[peaks], amplitudes[peaks], s=20, marker="x", c="r") plt.plot(np.arange(0, 0.2, 0.001), exponential(np.arange(0, 0.2, 0.001), *fit_params)) plt.legend(["Raw data", "Fit: " + "y={0:.2f}".format(fit_params[0]) + '*E^(-x/' + "{0:.2f}".format(1/fit_params[1]) + ") + " + "{0:.2f}".format(fit_params[2]), "Filtered peaks"])
def main(): if len(sys.argv) != 2: print('.') print('.') print('.') print( 'Number of parameters does not add up. Please enter command e.g. like this:' ) print('python transform_h5_to_csv.py test') print(' ') print('Nothing was done') return -1 filename = sys.argv[1] if filename[-3:] == '.h5': filename = filename[:-3] import os.path if not os.path.isfile(filename + '.h5'): print('.') print('.') print('.') print("The following file did not exist:") print(filename + '.h5') print(' ') print('Nothing was done') return -2 f = h5py.File(filename + '.h5', 'r') t_data = np.array(f['t']) t_0 = np.array(f['t_0']) x_data = np.array(f['x_data']) x_data[0, :10] y_data = np.array(f['y_data']) samples = y_data.shape[1] datapoints = y_data.shape[0] assert np.max(np.std(x_data, 0)) < 1e-10 # If this assertion catches, your x-axis changes during the experiment! # Gaussian blur in order to find potential approximate minima gauss_data = np.zeros_like(y_data) sigma = 10 print("Standard deviation for gaussian bluring: " + str(np.round(sigma * (x_data[0, 1] - x_data[0, 0]), 3)) + " MHz") for i in range(y_data.shape[0]): gauss_data[i, :] = gauss(y_data[i, :], sigma) # Get all minima. Do so by looking at the change in sign of the derivative. # A minima needs to be below -0.2 to be relevant! diff_data = gauss_data[:, 1:] - gauss_data[:, :-1] minima = np.zeros_like(y_data) minima[:, 1:-1] = ((diff_data[:, :-1] < 0) * 1.) * ( (diff_data[:, 1:] > 0) * 1.) * ((y_data[:, 1:-1] < -0.2) * 1.) # Calculate here the approximal values based on the minima approach approx_minima = np.ones_like(y_data[:, 0]) * -1. for i in range(0, y_data.shape[0], 1): # Get index of all the minima in ith trial temp_minima = np.argwhere(minima[i, :]) temp_minima = np.array( [temp_minima[index][0] for index in range(temp_minima.shape[0])]) if temp_minima.shape[0] > 0: # Get the blurred values of these minima values_minima = gauss_data[i, temp_minima] # Get the smallest minimum in case of multiple minima arg_smallest = np.argmin(values_minima) # Get the index of the smallest minimum smallest_min = temp_minima[arg_smallest] approx_minima[i] = smallest_min # Define the pdf of a Polynomial def poly_pdf(x, a, b, c, d, e, f): return a + b * x + c * (x**2) + d * (x**3) + e * (x**4) + f * (x**5) # Calculate now the minima based on fit around the data points from the approximal values slength = 10 # Defines the region where to search for lowest point first (2*slength+1) dlength = 6 # Defines how many data points to consider left and right to the minimum (2*dlength+1) fit_minima = np.copy(approx_minima) for i in range(fit_minima.shape[0]): approx_i = approx_minima[i] if approx_i >= 0: # This means the minimum is relevant # Find first actual minima in data, since blurring shifts that peak lower_bound = max(approx_i - slength, 0) upper_bound = min(approx_i + slength + 1, x_data.shape[1]) x_data_i = np.arange(int(lower_bound), int(upper_bound)) y_data_i = y_data[i, int(lower_bound):int(upper_bound)] approx_i = np.argmin(y_data_i) + lower_bound approx_minima[i] = approx_i # Update minimum to actual minimum lower_bound = max(approx_i - dlength, 0) upper_bound = min(approx_i + dlength + 1, x_data.shape[1]) x_data_i = np.arange(int(lower_bound), int(upper_bound)) y_data_i = y_data[i, int(lower_bound):int(upper_bound)] p, _ = fit(poly_pdf, x_data_i - approx_i, y_data_i) #,p0=[1,1,1,approx_i,1]) def current_polynomial(x): return p[0] + p[1] * x + p[2] * (x**2) + p[3] * ( x**3) + p[4] * (x**4) + p[5] * (x**5) #assert i!=2260 f = minimize(current_polynomial, x0=0) fit_minima[i] = f.x + approx_i if temp_minima.shape[0] > 0: # Get the blurred values of these minima values_minima = gauss_data[i, temp_minima] # Get the smallest minimum in case of multiple minima arg_smallest = np.argmin(values_minima) # Get the index of the smallest minimum smallest_min = temp_minima[arg_smallest] approx_minima[i] = smallest_min # Transform the fitted positions to actual frequencies resonant_freq = np.zeros_like(fit_minima) for i in range(resonant_freq.shape[0]): if fit_minima[i] > 0: min_full = int(fit_minima[i] // 1 + 0.5) min_diff = fit_minima[i] - min_full resonant_freq[i] = x_data[i, min_full] + min_diff * ( x_data[i, min_full + 1] - x_data[i, min_full]) # Write data into file with open(filename + '.csv', 'w') as f: # Write header s = str(t_0) for i in range(samples): s += ',' + str(x_data[0, i]) s += ',f0' f.write(s) f.write('\n') for j in range(datapoints): s = str(t_data[j]) for i in range(samples): s += ',' + str(y_data[j, i]) s += ',' + str(resonant_freq[j]) f.write(s) f.write('\n')
4.27, 3, 1.8, 1.48, 1.23, 1.03, 0.867, 0.746, 0.63] ''' #Distilled water data x = [0.002, 0.006, 0.01, 0.02, 0.04, 0.06, 0.07, 0.1, 0.12, 0.14, 0.16] y = [7.84, 7.73, 7.46, 7.27, 6.15, 4.71, 3.76, 1.66, 0.98, 0.56, 0.35] fit_params, fit_error = fit(exponential, x, y, p0=(6.5, 20, 1)) errors = np.divide(np.sqrt(np.diag(fit_error)) * 100, fit_params) plt.title("Spin-echo T2 measurement for distilled water") plt.xlabel("$2 \\tau$ (s)") plt.ylabel("Amplitude (V)") plt.scatter(x, y, marker="x", c="r", s=20.) plt.plot(np.arange(0, 0.16, 0.0001), exponential(np.arange(0, 0.16, 0.0001), *fit_params)) plt.legend([ "Fit: " + "y={0:.2f}".format(fit_params[0]) + '*E^(-x/' + "{0:.2f}".format(1 / fit_params[1]) + ") + " + "{0:.2f}".format(fit_params[2]), "Raw data" ])
NN = np.array( [50,100,150,200,250] ) #Values of N to time TT = np.zeros(len(NN)) for i in range(len(NN)): #Redifine uvvis_cropped with the number of antennae desired for timing #This change is then reflected in uvvis_cropped within part_two() #This way, finding uvvis_cropped is not included in the timing of part_two() rows,antennae = get_selection(pos,vis,NN[i],order) uvvis_cropped = np.zeros( (len(rows),vis.shape[1]) ) for j in range(len(rows)): uvvis_cropped[j] = uvvis[rows[j]] #Time the FFT routine TT[i]=timeit.timeit('part_two()',setup='from proj import part_two',number=1) print NN[i],TT[i] #Fit an NlogN trend to the timings a,c = fit( nlogn, NN, TT )[0] #Plot the results NN_sm = np.linspace(0,300,100) mpl.figure() mpl.plot(NN,TT,'ko') mpl.plot(NN_sm,nlogn(NN_sm,a,c),'r-',label=r"$%.2en\log n + %.2f$" % (a,c)) mpl.ylabel("$t$",fontsize=20) mpl.xlabel("$N$",fontsize=20) mpl.xlim(0,300) mpl.ylim(14.5,16) mpl.legend() mpl.savefig("FFT_image_timing.pdf") mpl.show()
3.43, 4.94, 6.45, 9.22, 6.32, 6.11, 4.63, 8.95, 7.8, 8.35, 11.45, 14.71, 11.97, 12.46, 17.42, 17.0, 15.45, 19.15, 20.86 ] """Linera regression""" slope, intercept, r_value, p_value, std_err = lin(x, y) """apparently a float conversion is needed to avoid numpy errors""" x = np.float64(x) LinFit = x * slope + intercept """Cube fitting""" def CubeFun(x, a, b, c, d): return a * (x**3) + b * (x**2) + c * x + d params, params_covariance = fit(CubeFun, x, y) CubeFit = CubeFun(x, *params) """integration""" A = quad(lambda x: CubeFun(x, *params), min(x), max(x)) """BIC calculation""" def BIC(y, yhat, k, weight=1): err = y - yhat sigma = np.std(np.real(err)) n = len(y) B = n * np.log(sigma**2) + weight * k * np.log(n) return B LineError = BIC(y, LinFit, 2)
starting_values1 = [420, 10, 30, -0.0005, 0.26] #large Peak starting_values2 = [550, 10, 30, -0.0005, 0.26] #medium peak starting_values3 = [585, 10, 30, -0.0005, 0.26] #small peak x_fit2 = [x if x >= 490 and x <= 620 else 0 for x in dset['x']] # Medium Peak x_fit1 = [x if x >= 350 and x <= 490 else 0 for x in dset['x']] # Large Peak x_fit3 = [x if x >= 570 and x <= 650 else 0 for x in dset['x']] # Small Peak y_fit1 = np.array(dset['y'])[np.nonzero(x_fit1)] y_fit2 = np.array(dset['y'])[np.nonzero(x_fit2)] y_fit3 = np.array(dset['y'])[np.nonzero(x_fit3)] x_fit1 = np.array(x_fit1)[np.nonzero(x_fit1)] x_fit2 = np.array(x_fit2)[np.nonzero(x_fit2)] x_fit3 = np.array(x_fit3)[np.nonzero(x_fit3)] fit_result1 = fit(fitfunc, x_fit1, y_fit1, starting_values1) fit_result2 = fit(fitfunc, x_fit2, y_fit2, starting_values2) fit_result3 = fit(fitfunc, x_fit3, y_fit3, starting_values3) outp.write('Fläche Gauss LPeak: {}\n'.format(fit_result1[0][2])) outp.write('Fläche Gauss MPeak: {}\n'.format(fit_result2[0][2])) outp.write('Fläche Gauss SPeak: {}\n'.format(fit_result3[0][2])) #print('Fläche Gauss: {}'.format(fit_result[0][2])) plt.plot(x_fit1, fitfunc(x_fit1, *fit_result1[0])) plt.plot(x_fit2, fitfunc(x_fit2, *fit_result2[0])) plt.plot(x_fit3, fitfunc(x_fit3, *fit_result3[0])) #plt.plot(x_fit, fitfunc(x_fit, *starting_values)) if mode == 'v': #plt.savefig('outp.png') plt.show() outp.close()
pressure = [] counter = 0 for i in range(len(p_all)): pressure.append( Bin(p_all[i], weight=w_all[i], bins=pres_bin, bounds=pres_range)) pdf = Density(p_all[i], weight=w_all[i], bounds=pres_range) guess = [ max(pdf.get_norm_y()), pres_mid, (pres_range[1] - pres_range[0]) / 16 ] popt, pcov = fit( model_func, pdf.get_x(), pdf.get_y(), p0=guess, bounds=[[.1 * max(pdf.get_norm_y()), .5 * pres_range[0], 0], [ 1.2 * max(pdf.get_norm_y()), pres_range[1], pres_range[1] / 4 ]], method='trf') A_fit, B_fit, C_fit = popt param.append(popt) gaussian = [] for i in pdf.get_x(): gaussian.append(model_func(i, A_fit, B_fit, C_fit)) NKDE_P.append([pdf.get_x(), pdf.get_norm_y(), gaussian, None]) counter += 1
def __main__(): # least squares algorithm N_ls = 100 M_ls = sample_complexity(least_squares, N_ls, 0.1) # perceptron algorithm N_p = 100 M_p = sample_complexity(perceptron, N_p, 0.1) # Winnow algorithm N_w = 150 M_w = sample_complexity(winnow, N_w, 0.1) # 1-NN algorithm N_nn = 15 M_nn = sample_complexity(one_nearest_neighbors, N_nn, 0.1) ########## plot all algorithms in 2,2 matrix plot ####### M = [M_ls, M_p, M_w, M_nn] N = [N_ls, N_p, N_w, N_nn] name = ['Least squares', 'Perceptron', 'Winnow', '1-NN'] fig, ax = plt.subplots(2, 2, figsize=(14, 14)) i = 0 for row in range(ax.shape[0]): for col in range(ax.shape[1]): ax[row, col] = plot_sample_complexity_ax(ax[row, col], N[i], M[i], name[i]) ax[1, col].set_xlabel('Dimension n', fontsize=18) i += 1 ax[row, 0].set_ylabel('Sample complexity m', fontsize=18) ######### Fit linear, log and exp functions ########## M = [M_ls, M_p, M_w, M_nn] N = [N_ls, N_p, N_w, N_nn] lin_fits = [] log_fits = [] exp_fits = [] lin_popts = [] log_popts = [] exp_popts = [] log_start = 1 for i, m in enumerate(M): n = np.arange(1, N[i] + 1) popt_lin, pcov_lin = fit(lin_func, n, m, bounds=([0, -5], [2, 5])) popt_log, pcov_log = fit(log_func, n, m, bounds=([-np.inf, 0, -np.inf], [np.inf, np.inf, np.inf])) popt_exp, pcov_exp = fit(exp_func, n, m) lin_popts.append(popt_lin) log_popts.append(popt_log) exp_popts.append(popt_exp) lin_fits.append(lin_func(n, *popt_lin)) log_fits.append(log_func(n, *popt_log)) exp_fits.append(exp_func(n, *popt_exp)) ############# plot all fits in 2,2 matrix plot ######### fig, ax = plt.subplots(2, 2, figsize=(14, 14)) i = 0 for row in range(ax.shape[0]): for col in range(ax.shape[1]): n = np.arange(1, N[i] + 1) ax[row, col] = plot_sample_complexity_ax(ax[row, col], N[i], M[i], name[i]) ax[row, col].plot(n, lin_fits[i], linestyle='--', label=(r'$f(n) = %.1f n + %.1f$' % (lin_popts[i][0], lin_popts[i][1]))) ax[row, col].plot(n, log_fits[i], linestyle='dotted', label=r'$f(n) = %.1f\cdot log(%.1f n) + %.1f$' % (log_popts[i][0], log_popts[i][1], log_popts[i][2])) ax[row, col].plot(n, exp_fits[i], linestyle='dashdot', label=r'$f(n) = %.1f\cdot exp(%.1f n)$' % (exp_popts[i][0], exp_popts[i][1])) ax[row, col].set_ylim([0, max(M[i]) + 3]) ax[row, col].legend() ax[1, col].set_xlabel('Dimension n', fontsize=18) i += 1 ax[row, 0].set_ylabel('Sample complexity m', fontsize=18)
def trace(line_data, center, check=False): xx = np.array([i / 100000 for i in range(len(line_data))]) # def fun(x,a,b,c,d,e,f,g,h,i): # return i*x**8+h*x**7+g*x**6+f*x**5+a*x**4+b*x**3+c*x**2+d*x**1+e def fun(x, c, d, e): return c * x**2 + d * x**1 + e #32 c r ти« base = 20 d = 1 #fitting right hand======================================== end = center + base + d + 1 aa = fit(fun, xx[center:end], np.array(line_data[center:end]))[0] while fun(xx[end - 1], aa[0], aa[1], aa[2]) > fun(xx[end - 2], aa[0], aa[1], aa[2]): #while fun(xx[end-1],aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],aa[6],aa[7],aa[8])>fun(xx[end-2],aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],aa[6],aa[7],aa[8]): end += d aa = fit(fun, xx[center:end], np.array(line_data[center:end]))[0] #plt.plot(xx[center:center+int(len(line_data)*(base+n*rate))],fun(xx[center:center+int(len(line_data)*(base+n*rate))],aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],aa[6],aa[7],aa[8])) r = end - 1 tem = r big = line_data[r] for i in range(center, r): if line_data[i] > big: big = line_data[i] tem = i r = tem #fitting left hand=========================================== start = center - (base + d) aa = fit(fun, xx[start:center + 1], np.array(line_data[start:center + 1]))[0] while fun(xx[start], aa[0], aa[1], aa[2]) > fun(xx[start + 1], aa[0], aa[1], aa[2]): #while fun(xx[start],aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],aa[6],aa[7],aa[8])>fun(xx[start+1],aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],aa[6],aa[7],aa[8]): start -= d aa = fit(fun, xx[start:center + 1], np.array(line_data[start:center + 1]))[0] #plt.plot(xx[center-int(len(line_data)*(base+n*rate)):center],fun(xx[center-int(len(line_data)*(base+n*rate)):center],aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],aa[6],aa[7],aa[8])) #plt.show() l = start tem = l big = line_data[l] for i in range(l + 1, center + 1): if line_data[i] > big: big = line_data[i] tem = i l = tem if check: plt.plot(xx, line_data) plt.scatter(xx[center], line_data[center]) plt.scatter(xx[l], line_data[l]) plt.scatter(xx[r], line_data[r]) plt.show() return l, center, r
def D(x): return (Dm - D0) * 10**3 def F(x): return (3 * L**2 * x - 4 * x**3) # np.savetxt('test3.txt', np.column_stack([x, D0, Dm, D(x), F(x)]), fmt="%2.2f", header="x D0 Dm D F") def g(a, m): return m * a param, cov = fit(g, F(x), D(x)) x_plot = np.linspace(0, 165, 1000) plt.plot(F(x), D(x), 'b.', label='Messwerte') plt.plot(x_plot, g(x_plot, *param), 'r-', label='lineare Regression') plt.xlabel(r'$\left(3 L^2 x - 4 x^3\right) \,/\, \mathrm{m^3}$') plt.ylabel(r'$D(x) \,/\, 10^{-3} \, \mathrm{m}$') plt.xlim(0, 0.175) plt.ylim(0, 1.2) plt.legend(loc='best') plt.grid() # plt.show() # plt.savefig('rundbeid1.pdf')
def getupdown(*args, **kwargs): filename, title, Sd, Sm, Sy, sh, sm, fh, fm, p, t = args ss = kwargs.pop('ss', 0) fs = kwargs.pop('fs', 0) Fd = kwargs.pop('Fd', None) Fm = kwargs.pop('Fm', None) Fy = kwargs.pop('Fy', None) preview = kwargs.pop('preview', False) bounds = kwargs.pop('bounds', [1, 1, 1, 1]) up = kwargs.pop('up', True) datetimeaxis = kwargs.pop('datetimeaxis', False) df = file_fetcher(filename, t) trimmed = df_trimmer(df, Sd, Sm, Sy, sh, sm, fh, fm, t, ss=ss, fs=fs, Fd=Fd, Fm=Fm, Fy=Fy) xforfit = get_x_for_fit(trimmed, Sd, Sm, Sy, t) yforfit = trimmed[p].to_list() xforplot = trimmed[t] fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(8.5, 11), constrained_layout=True) ax[0].set_title(title) ax[0].set_xlabel("Datetime") ax[0].plot(df[t], df[p], c='b', label=title) ax[0].plot(trimmed[t], trimmed[p], c='red') ax[0].grid(True) if up: fitvars, _ = fit( spin_up, xforfit, yforfit) #, bounds=[(0, 83500, 0),(numpy.inf, 100000, numpy.inf)]) print("\n\nSpin up:", "pmax*(1-numpy.exp(-(t-t0)/tau))+shift\n") print(title) print("pmax", "t0", "tau", 'shift') for i, val in enumerate(["pmax:", "t0:", "tau:", "shift:"]): print(fitvars[i], end='\t') print('') fy = spin_up(xforfit, fitvars[0], fitvars[1], fitvars[2], fitvars[3]) if datetimeaxis: ax[1].plot(xforplot, fy, c='green', label="Spin Up") else: ax[1].plot(xforfit, fy, c='green', label="Spin Up") else: fitvars, _ = fit( spin_down, xforfit, yforfit) #, bounds=[(0, 83500, 0),(numpy.inf, 100000, numpy.inf)]) print("\n\nSpin down:", "p0*numpy.exp(-(t-t0)/tau)+shift\n") print(title) print(["p0", "t0", "tau", "shift"]) for i, val in enumerate(["p0:", "t0:", "tau:", "shift:"]): print(fitvars[i], end='\t') fy = spin_up(xforfit, fitvars[0], fitvars[1], fitvars[2], fitvars[3]) if datetimeaxis: ax[1].plot(xforplot, fy, c='green', label="Spin Down") else: ax[1].plot(xforfit, fy, c='green', label="Spin Down") if datetimeaxis: ax[1].set_xlabel("Datetime") ax[1].scatter(trimmed[t], trimmed[p], c='red') else: ax[1].set_xlabel("Seconds since Midnight") ax[1].scatter(xforfit, trimmed[p], c='red') ax[1].plot(xforfit, fy, c='green', label=("Spin " + ("Up" if up else "Down"))) ax[1].grid(True) ax[1].legend(loc='best') ax[0].legend(loc='best') return fig
# data[1] is sigma rtwolog = sqrt(2*log(2)) # Load in the datafile that has the angular error as a function of particle energy angdata = np.transpose(np.loadtxt(os.path.join(os.path.dirname(__file__),"angerror.txt"), delimiter=",")) # the fit is best when done in log-space of energy # so we do a little fitty-fit logged = np.log10(angdata[0]) from scipy.optimize import curve_fit as fit def func(x, c1,c2,c3): return( c1 + c2*x + c3*(x**2) ) popt, pcov = fit(func, logged, angdata[1]) def get_ang_error(energy): """ Returns a best-guess for the angular error - the FIFTYth percentile Energy should be a float and in GeV """ if not isinstance(energy, (int,float)): raise TypeError("Expected {}, got {}".format(float, type(energy))) try: # we really want to just use the data, so let's try interpolating first error = get_closest( energy, angdata[0], angdata[1] ) except ValueError: # failing that we use the fit (which isn't as good)
# define the model of post-burnout flight we'll use to fit the data and # pull out the drag coefficient def amodel(v, C_d): rho = 2.3 * 10**-3 A = 4 * sp.pi / 144 M = 7.75 / 32.2 return (rho * v**2 * C_d * A) / (2 * M) # apply a non-linear least squares fit to our post burnout, pre data-gap # (possibly caused by brake deployment) a2x data using the velocities (found by # integrating a2x) as the independent variable in the model defined above, then # extract the drag coefficient # JOHN: the (1.5 < data.time) business is to specify that the regression should # apply only to our post-burn pre-gap data nlregress = fit(amodel, # the model defined above data.v2x[(1.5 < data.time) & (data.time < 3)], # indep. data data.a2x[(1.5 < data.time) & (data.time < 3)]) # dep. data # get value we want (C_d) from returned data structure and print it dragcoeff = nlregress[0][0] print dragcoeff # result is -0.244946411454 # plot a2x with integrated vel and accel along with model fit. plt.plot(data.time, data.a2x, '.-', data.time, data.v2x, '.-', data.time, data.x2x, '.-', data.time, amodel(data.v2x, dragcoeff)) plt.show() #plt.savefig('plots/test4ints.png', bbox_inches=None, dpi=160)
def fit_line(starting_values, xval, yval): fitfunc = lambda x, m: line(x, m, 0) fit_result = fit(fitfunc, xval, yval, starting_values) print(fit_result) return fit_result
R = 102.8e3 ws = 1 / (R * C) # omega Rd_arr, deltat_arr, Vpp_arr, dt_arr, dV_arr = readCSV('data1.csv', skiprows=1) for i in range(4): filename = base_filename + str(i) + '.csv' t, V = readCSV(filename, skiprows=2) t -= t[0] N = len(V) # number of points print("Measured frequency =", 1 / deltat_arr[i], "(expected %1f)" % (ws / (2 * np.pi))) # I use lambdas to change fit parameters (in this case I decided to set w and fit phi) params = fit( lambda t, A, phi1, B, phi2, C: func(t, ws, A, phi1, B, phi2, C), t, V, p0=[1, 3 * np.pi / 4, 1, 3 * np.pi / 4, 0]) A, phi1, B, phi2, C = params[0] print("A = %.2f \t phi1 = %.2f \t B = %.2f \t phi2 = %.2f \t C = %.2f" % (A, phi1 % (2 * np.pi), B / ws, phi2 % (2 * np.pi), C)) print("Coefficient ratio (x100) %.2f" % (100 * B / ws * A)) plt.subplot(121) plt.plot(t * 1000, V, color='royalblue', linewidth=2.0, label='Experimental data') plt.plot(t * 1000,