def mean(values, axis=0): """Returns mean values and their mean errors of a given array. Return value will be a unp.uarray Args: values: (list) Array containing numbers whose mean is desired. axis: (int) Axis along which the means are computed. The default is to compute the mean of the flattened array. """ return unp.uarray(np.mean(noms(values), axis=axis), scipy.stats.sem(noms(values), axis=axis))
def plotElement(anodenstrom, spannung, V_N, R): spannung /= (V_N**2 * 1000**2 * 10) # verstärkung rausrechnen x = anodenstrom*10**(-3) y = spannung/(R**2) # I^2 bestimmt plt.errorbar(noms(x), noms(y), xerr=stds(x), yerr=stds(y), fmt='kx', label='Messwerte') # fitten: params, covariance = curve_fit(fitfunktion, unp.nominal_values(x), unp.nominal_values(y), p0=[1]) errors = np.sqrt(np.diag(covariance)) print('m= ', params[0], '±', errors[0]) m = ufloat(params[0], errors[0]) x_fit = np.linspace(-0.0001, max(noms(x))+0.001) plt.plot(x_fit, fitfunktion(x_fit, *params), label='Fit') plt.xlim(0, 0.0045) plt.ylim(0, 1.75e-17) plt.xlabel(r'$I_0 \:/\: \si{\ampere}$') plt.ylabel(r'$I^2 \:/\: \si{\ampere\squared}$') delta_nu = ufloat(24.4, 0.4) delta_nu *= 10**3 e0 = m/(2*delta_nu) print("e0 = ", e0) e0theorie = ufloat(constants.physical_constants["elementary charge"][0], constants.physical_constants["elementary charge"][2]) print("Abweichung von Theorie= ", abweichungen(e0theorie, e0)) plt.legend(loc='best') # in matplotlibrc leider (noch) nicht möglich plt.tight_layout(pad=0.2, h_pad=1.08, w_pad=1.08) plt.savefig('build/plotElement.pdf') plt.close()
def Plot(x=[], y=[], limx=None, limy=None, xname='', yname='', name='', markername='Wertepaare', marker='rx', linear=True, linecolor='b-', linename='Ausgleichsgerade', xscale=1, yscale=1, save=True, Plot=True): uParams = None if(Plot): dx = abs(x[-1]-x[0]) if(limx==None): xplot = np.linspace((x[0]-0.05*dx)*xscale,(x[-1]+0.05*dx)*xscale,1000) else: xplot = np.linspace(limx[0]*xscale,limx[1]*xscale,1000) if(save): plt.cla() plt.clf() plt.errorbar(noms(x)*xscale, noms(y)*yscale, xerr=stds(x)*xscale, yerr=stds(y)*yscale, fmt=marker, markersize=6, elinewidth=0.5, capsize=2, capthick=0.5, ecolor='g',barsabove=True ,label=markername) if(linear == True): params, covar = curve_fit(Line, noms(x), noms(y)) uParams=uncertainties.correlated_values(params, covar) if(Plot): plt.plot(xplot*xscale, Line(xplot, *params)*yscale, linecolor, label=linename) if(Plot): if(limx==None): plt.xlim((x[0]-0.05*dx)*xscale,(x[-1]+0.05*dx)*xscale) else: plt.xlim(limx[0]*xscale,limx[1]*xscale) if(limy != None): plt.ylim(limy[0]*yscale,limy[1]*yscale) plt.xlabel(xname) plt.ylabel(yname) plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) if(save): plt.savefig('build/'+name+'.pdf') if(linear): return(uParams)
def mean(values, axis=0): """Returns mean values and their mean errors of a given array. Return value will be a unp.uarray Args: values: (list) Array containing numbers whose mean is desired. axis: (int) Axis along which the means are computed. The default is to compute the mean of the flattened array. """ return unp.uarray((np.mean(noms(values), axis=axis), scipy.stats.sem(noms(values), axis=axis)))
def plotalpha(alpha_mz, mass_Z): mu = np.logspace(-1, 30, 10000) alf = alpha(alpha_mz, mass_Z, mu) plt.fill_between(mu, noms(alf) + stds(alf), noms(alf) - stds(alf), color='red', label='1$\sigma$-Intervall') plt.plot(mu, noms(alf), label='Kurve') d = np.zeros(len(alf)) d = noms(alf) - 1 / 128 print(d) for i in range(len(d) - 1): if d[i] == 0. or d[i] * d[i + 1] < 0.: # crossover at i print('Grafische Lösung:', alf[i]) plt.xlim(0.1, 1000) plt.xlabel(r'$\mu \:/\: \si{\giga\electronvolt}$') plt.ylabel(r'$\alpha_S$') plt.legend(loc='best') plt.xscale('log') # in matplotlibrc leider (noch) nicht möglich plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/plotalpha.pdf') plt.close()
def table(name, data): j=0 i=0 f = np.zeros(len(data)) for i in range(len(data)): if(type(data[i][0]) == type(dummy) or type(data[i][0]) == type(dummyarray[1]) or type(data) == type(udummyarray)): f[i] = True else: f[i] = False print(f) #Runden for i in range(len(data)): if(f[i]): for j in range(data[0]): sdevs(data[i][j]) = rts(sdevs(data[i][j])) noms(data[i][j]) = round((noms(data[i][j]), -int(m.floor(m.log10(abs(x)))))) output = open(name, 'w') output.write(r'\begin{table}[h]' + '\n' + r'\centering' + '\n' + r'\caption{CAPTION}' + '\n' +r'\sisetup{%uncertainty-seperator = {\,},'+'\n'+r'table-number-alignment = center,'+'\n'+'table-unit-alignment = center,'+'\n'+'%table-figures-integer = 1,'+'\n'+'%table-figures-decimal = 1,'+'\n'+'table-auto-round = true'+'\n'+'}'+'\n'+ r'\begin{tabular}{ ') for i in range(len(data)): if(f[i]): output.write(r'S[table-format= 3.1]'+'\n'+' @{\,$\pm{}$\,} '+'\n' + r' S[table-format= 3.1] ') else: output.write(r' S[table-format= 3.1] '+'\n') output.write(r'}' + '\n' + r'\toprule' + '\n') for i in range(len(data)): if(i < (len(data)-1)): if(f[i]): output.write(r'\multicolumn{2}{c}{TITLE}'+'\n'+'&') else: output.write(r'{$\text{Title}$}'+'\n'+'&') else: if(f[i]): output.write(r'\multicolumn{2}{c}{TITLE} \\'+'\n') else: output.write(r'{$\text{Title}$} \\'+'\n') output.write(r' \midrule' + '\n') #Tabelle for j in range(len(data[0])): i = 0 while i <= len(data)-1: if(f[i]): if(i == len(data)-1): output.write(str(data[i][j].n) + '&' + str(data[i][j].s) + r'\\' + '\n') else: output.write(str(data[i][j].n)+ '&' + str(data[i][j].s) + '&') i = i+1 else: if(i == len(data)-1): output.write(str(data[i][j]) + r'\\' + '\n') else: output.write(str(data[i][j]) + '&') i = i+1 #Tabelle Ende output.write(r'\bottomrule' + '\n' + r'\end{tabular}' + '\n' + r'\label{tab:LABEL}' + '\n' + r'\end{table}') output.close()
def plot(x, y, file, fitfunktion, tau_erw, abklingzeit_erw, x_fit=None, xlim=None, ylim=None): plt.errorbar(unp.nominal_values(x), unp.nominal_values(y), xerr=unp.std_devs(x), yerr=unp.std_devs(y), fmt='-', label='Messwerte') # maxima finden x_nom = noms(x) y_nom = noms(y) left_right = 1 ende = 30 start = 30 maxima_x = [] maxima_y = [] for i in range(start, len(x_nom)-ende): if y_nom[i-left_right]<y_nom[i] and y_nom[i+left_right]<=y_nom[i] and y_nom[i-3]<y_nom[i] and y_nom[i+3]<y_nom[i]: maxima_x.append(x_nom[i]) maxima_y.append(y_nom[i]) #i += 500 maxima_x, maxima_y = maxima_x[:14], maxima_y[:14] plt.plot(maxima_x, maxima_y, 'x', label='Maxima') maxima_x = np.asarray(maxima_x) U_0 = 0.000007 # fitten: if x_fit is not None: params, covariance = curve_fit(fitfunktion, maxima_x, maxima_y, p0=[tau_erw.n, U_0]) errors = np.sqrt(np.diag(covariance)) print('tau= ', params[0] * 1e3, '±', errors[0] * 1e3) k = ufloat(params[0], errors[0]) print('U_0= ', params[1], '±', errors[1]) U_0 = ufloat(params[1], errors[1]) print('Abweichung von tau_erw = ', abweichungen(tau_erw, k), '%') x_fit = np.linspace(x_fit[0], x_fit[1], 10000) plt.plot(x_fit, fitfunktion(x_fit, *params), label='Fit') label=r'Maximum$\:/\:e$' #label='test' plt.plot((xlim[0], xlim[1]), (maxima_y[0]/np.e, maxima_y[0]/np.e), label=label) for x_loop in x_fit: if fitfunktion(x_loop, *params) < maxima_y[0]/np.e: print('Abklingzeit =', x_loop - maxima_x[0], abklingzeit_erw, abweichungen(abklingzeit_erw, x_loop - maxima_x[0])) break if xlim is not None: plt.xlim(xlim[0], xlim[1]) if ylim is not None: plt.ylim(ylim[0], ylim[1]) xlabel = r'$t\:/\:\si{\second}$' ylabel = r"$U_\text{A}\:/\:\si{\volt}$" #xlabel, ylabel = 'test', 'test' plt.xlabel(xlabel) plt.ylabel(ylabel) plt.legend(loc='best') # in matplotlibrc leider (noch) nicht möglich plt.tight_layout(pad=0.2, h_pad=1.08, w_pad=1.08) plt.savefig('build/'+file+'.pdf') plt.close()
def automatic_spectrum_anaysis( channel_content, index_of_peak, fit_function, ): # use as fit_intervall \pm 15, create for fit numpy array with index values index_channel = np.arange(index_of_peak - 15, index_of_peak + 15, 1) index = noms(g(index_channel, m, b)) params_gaus, cov_gaus = curve_fit( fit_function, index, channel_content[index_channel], p0=[channel_content[index_of_peak], 1, noms(g(index_of_peak, m, b))]) error_gaus = np.sqrt(np.diag(cov_gaus)) amplitude = ufloat(params_gaus[0], error_gaus[0]) sigma = ufloat(params_gaus[1], error_gaus[1]) offset = ufloat(params_gaus[2], error_gaus[2]) # --- Calculate area under peak --- # area_under_peak = sum(channel_content[index_of_peak - 5:index_of_peak + 5]) # --- Plot function --- # index_fit_plot = np.linspace(index_of_peak - 15, index_of_peak + 15, 1e4) #plt.clf() #plt.xlim(noms(g(index_of_peak, m, b))-1, noms(g(index_of_peak, m, b))+1) #plt.ylim(0, channel_content[index_of_peak] * 1.2) #plt.hist(noms(g(np.arange(0, len(channel_content_sb_ba), 1), m, b)), # bins=noms(g(np.linspace(0, len(channel_content_sb_ba), # len(channel_content_sb_ba)), m, b)), # weights=channel_content_sb_ba, label='Spektrum') #plt.plot(index_fit_plot, fit_function(index_fit_plot, *params_gaus), # label='Fit') #plt.xlabel(r'$\mathrm{Channel}$') #plt.ylabel(r'$\mathrm{Count}$') #plt.legend() #plt.savefig(f'./plots/sb_or_ba/spectrum_fit_at_index_{str(index_of_peak)}.pdf') # --- Return values --- # return amplitude, sigma, offset, int(area_under_peak)
def plotWiderstand(widerstand, spannung, V_N, dateiname, T): spannung = unp.uarray(spannung, 0.005) widerstand = unp.uarray(widerstand, 1) y = spannung / V_N**2 x = widerstand plt.errorbar(unp.nominal_values(x), unp.nominal_values(y), xerr=unp.std_devs(x), yerr=unp.std_devs(y), fmt='kx', label='Messwerte') # fitten: params, covariance = curve_fit(fitfunktion, unp.nominal_values(x), unp.nominal_values(y), p0=[0.1]) errors = np.sqrt(np.diag(covariance)) print('m= ', params[0], '±', errors[0]) m = ufloat(params[0], errors[0]) x_fit = np.linspace(-5, max(noms(x)) + 1000) plt.plot(x_fit, fitfunktion(x_fit, *params), label='Fit') # kBoltzmann if dateiname == "1" or dateiname == "2": #int, intf = np.genfromtxt('build/eichungeinfach.txt', unpack='True') int = ufloat(4.9486e11, 0.001e11) else: #int, intf = np.genfromtxt('build/eichungKorrelator.txt', unpack='True') int = ufloat(7.41e9, 0.04e9) #int = ufloat(int, intf) T = ufloat(296.15, 2) # K k_B = m / (4 * int * T) print('k_B_', dateiname, " = ", k_B) kBTheorie = ufloat(constants.physical_constants["Boltzmann constant"][0], constants.physical_constants["Boltzmann constant"][2]) print("Abweichung von Theorie= ", abweichungen(kBTheorie, k_B)) plt.xlabel(r'$R/\si{\ohm}$') plt.ylabel(r'$U_\text{A} \:/\: \si{\volt\squared}$') plt.xlim(0, 1.01 * max(noms(x))) plt.legend(loc='best') # in matplotlibrc leider (noch) nicht möglich #plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/plotWiderstand' + dateiname + '.pdf') plt.close()
def SelectPeaks(self): """ Function opens a Window with the data, you can choose initial values for the peaks by clicking on the plot. """ fig, ax = plt.subplots() ax.plot(self.x, self.y) polyparams = self.Fitbaseline() ax.plot(self.x, poly(self.x, *noms(polyparams)), 'r-') x = [] y = [] def onclickpeaks(event): if event.button: x.append(event.xdata) y.append(event.ydata) plt.plot(event.xdata, event.ydata, 'ko') fig.canvas.draw() cid = fig.canvas.mpl_connect('button_press_event', onclickpeaks) figManager = plt.get_current_fig_manager() figManager.window.showMaximized() plt.show() np.savetxt(self.label + '/locpeak_' + self.label + '.txt', np.transpose([np.array(x), np.array(y) ])) # store the chosen initial values self.peakfile = self.label + '/locpeak_' + self.label + '.txt'
def make_table(columns, figures=None): assert hasattr(columns[0],'__iter__'), "Wenn nur eine Zeile von Daten vorliegt, funktioniert zip nicht mehr; die Elemente von columns müssen Listen sein, auch wenn sie ihrerseits nur ein Element enthalten." if figures is None: figures = [None] * len(columns) cols = [] for column, figure in zip(columns, figures): assert (type(column) != str), "Hier ist ein einzelner String übergeben worden. Baue daraus eine Liste und alles ist gut ( column = [string] )." if (type(column) == list): col = zip(*zip(column)) # hard to find this kind of code... this will unzip the list column, ref: https://docs.python.org/3/library/functions.html#zip cols.extend(col) elif np.any(stds(column)): if figure is None: figure = '' col = list(zip(*['{0:.{1:}uf}'.format(x, figure).split('+/-') for x in column])) else: col = list(zip(*[['{0:.{1:}f}'.format(x, figure)] for x in noms(column)])) cols.extend(col) max_lens = [max(len(s) for s in col) for col in cols] cols = [['{0:<{1:}}'.format(s, ml) for s in col] for col, ml in zip(cols, max_lens)] rows = list(itertools.zip_longest(*cols)) return (r' \\' + '\n').join([' & '.join(s for s in row if s is not None) for row in rows]) + r' \\'
def write_table(columns, filename, figures=None, row_names=None, column_names=None, dont_align=False): """Generates just the table contents and writes it to the given file.""" assert hasattr(columns[0], '__iter__'), "Wenn nur eine Zeile von Daten vorliegt, funktioniert zip nicht mehr; die Elemente von columns müssen Listen sein, auch wenn sie ihrerseits nur ein Element enthalten." if figures is None: figures = [None] * len(columns) if dont_align: number_format = '\\num{{{0:.{1:}g}}}' else: number_format = '{0:.{1:}g}' cols = [] for column, figure in zip(columns, figures): if np.any(stds(column)): if figure is None: figure = '' col = list(zip(*['{0:.{1:}uf}'.format(x, figure).split('+/-') for x in column])) else: col = list(zip(*[[number_format.format(x, figure)] for x in noms(column)])) cols.extend(col) max_lens = [max(len(s) for s in col) for col in cols] cols = [['{0:<{1:}}'.format(s, ml) for s in col] for col, ml in zip(cols, max_lens)] rows = list(itertools.zip_longest(*cols)) if row_names is not None: for i in range(len(rows)): rows[i] = [row_names[i]] + list(rows[i]) if column_names is not None: rows = [column_names] + list(rows) # ["$\text{{{0}}}".format(i) for i in column_names] filecontent = (r' \\' + '\n').join([' & '.join(s for s in row if s is not None) for row in rows]) + r' \\' write(filename, filecontent)
def make_table(columns, figures=None): assert hasattr( columns[0], '__iter__' ), "Wenn nur eine Zeile von Daten vorliegt, funktioniert zip nicht mehr; die Elemente von columns müssen Listen sein, auch wenn sie ihrerseits nur ein Element enthalten." if figures is None: figures = [None] * len(columns) cols = [] for column, figure in zip(columns, figures): if np.any(stds(column)): if figure is None: figure = '' col = list( zip(*[ '{0:.{1:}uf}'.format(x, figure).split('+/-') for x in column ])) else: col = list( zip(*[['{0:.{1:}f}'.format(x, figure)] for x in noms(column)])) cols.extend(col) max_lens = [max(len(s) for s in col) for col in cols] cols = [['{0:<{1:}}'.format(s, ml) for s in col] for col, ml in zip(cols, max_lens)] rows = list(itertools.zip_longest(*cols)) return (r' \\' + '\n').join( [' & '.join(s for s in row if s is not None) for row in rows]) + r' \\'
def transform2latex_tab_2(data, dir, dataname): if not os.path.exists(dir): os.makedirs(dir) size = len(data) save_data = open((dir + 'latex_' + dataname), 'w') print('\nSaving data to "%s"' % (dir + dataname)) for i in range(0, size): array_len = len(data[i]) for j in range(0, array_len): if (j == array_len - 1): save_data.write("\\num{" + str(noms(data[i][j])) + " \\pm " + str(stds(data[i][j])) + "}\t \\\\ \n") else: save_data.write("\\num{" + str(noms(data[i][j])) + " \\pm " + str(stds(data[i][j])) + "}\t & \t") save_data.close()
def getOutValues(pFighterStrings, pEnemieStrings, pAttStats, pDefStats): vOutputString = 'Kampfstats fuer ' + pFighterStrings[ 0] + ' gegen ' + pEnemieStrings[0] + ':' for u in range(0, len(pAttStats[0])): vOutLine = '\n' + pEnemieStrings[0] + ' ' + pEnemieStrings[u + 1] + ':\t\t' for i in range(0, len(pAttStats)): vAT = ufloat(np.round(noms(pAttStats[i][u]), 1), np.round(stds(pAttStats[i][u]), 1)) vPA = ufloat(np.round(noms(pDefStats[i][u]), 1), np.round(stds(pDefStats[i][u]), 1)) vOutLine += 'AT {}, PA {};\t'.format(vAT, vPA) vOutputString += vOutLine return vOutputString
def gk_plot(name, winkel, gk, funktion, korr, fitgrenzen): params, errors = cf(funktion, np.cos(inrad(winkel[fitgrenzen[0]:fitgrenzen[1]]))**2, noms(gk[fitgrenzen[0]:fitgrenzen[1]])) g_plot = np.linspace(0, 1) plt.errorbar(np.cos(inrad(winkel))**2, noms(gk) * 1e10, xerr=korr(winkel), yerr=stds(gk) * 1e10, fmt='x', label=r'Messwert') plt.plot(g_plot, funktion(g_plot, *params) * 1e10, label=r'Fit') plt.xlabel(r'$\cos^2\left(\theta\right)$') plt.ylabel(r'$a \:/\: \si{\angstrom}$') plt.legend(loc='best') plt.tight_layout() plt.savefig("build/plot_" + name + ".pdf") plt.close() return (unp.uarray(params[1], np.sqrt(np.diag(errors)[1])))
def plotPhis(pPhis): vX = range(1, len(pPhis) + 1) plt.plot(vX, noms(np.array(pPhis)), 'r-') plt.errorbar(vX, noms(np.array(pPhis)), yerr=stds(np.array(pPhis)), color='k', fmt='x') #plt.ylim(-0.05, 1.05) plt.xlabel('Anzahl an Bestfeatures', {'size': '16'}) plt.ylabel('$\Phi$', {'size': '16'}) plt.title('$\Phi$-Scores') plt.legend(loc='best', prop={'size': 16}) plt.tight_layout() plt.savefig('Bilder/PhiScores.pdf') plt.show() plt.clf()
def tabelle_fertig(r, winkel, hkl, a_m_hkl, name): hkl_sum = hkl[:, 0]**2 + hkl[:, 1]**2 + hkl[:, 2]**2 rundung = np.array([1, 2, 0, 0, 0, 0, 2, 2, 3]) hkl_table = np.array([ r * 100, winkel, hkl[:, 0], hkl[:, 1], hkl[:, 2], hkl_sum, noms(a_m_hkl) * 10**(10), stds(a_m_hkl) * 10**(10), np.cos(inrad(winkel))**2 ]) tabelle(hkl_table, name + "_table", rundung)
def Miriam_n(Druck,M,L = L, Lambda = 632.99e-9): n = Lambda/L * M + 1 params, cov = curve_fit(f, Druck, noms(n)) errors = np.sqrt(np.diag(cov)) params = unp.uarray(params,errors) T_0 = 15 + 273.15 Steigung_norm = params[0] * T/T_0 atm = 1.01325e3 n_atm = Steigung_norm * atm + params[1] return [params,Druck,n,n_atm]
def lnint(T, I, hr): array = np.array([]) for t in T: if t == T[-1]: break array = np.append( array, np.log( np.abs(np.trapz(np.abs(I[T >= t]), T[T >= t])) / (np.abs(I[T == t]) * noms(hr)))) return array
def plot(x, y, label, filename, x_label, y_label, fitfunktion, p_list, pname_list): plt.errorbar(unp.nominal_values(x), unp.nominal_values(y), xerr=unp.std_devs(x), yerr=unp.std_devs(y), fmt='kx', label='Messwerte '+label) werte_start = 0 werte_ende = len(x)-1 params, covariance = curve_fit(fitfunktion, unp.nominal_values(x[werte_start:werte_ende]), unp.nominal_values(y[werte_start:werte_ende]), p0=p_list) errors = np.sqrt(np.diag(covariance)) for i, name in enumerate(pname_list): print('{0} = {1} ± {2}'.format(name, round(params[i], 5), round(errors[i], 5))) # print('I_0= ', params[0], '±', errors[0]) # print('phi_verschieb= ', params[1], '±', errors[1]) # print('m = ', params[2], '±', errors[2]) # m = ufloat(params[0], errors[0]) x_fit = np.linspace(noms(x[0])-(noms(x[-1]))*0.1, (noms(x[-1]))*1.1, 1000) plt.plot(x_fit, fitfunktion(x_fit, *params), label='Fit ' + label) # plotting plt.legend(loc='best') plt.xlim(noms(x[0])-(noms(x[-1]))*0.06, (noms(x[-1]))*1.06) # y_label, x_label= 'test', 'x_label' plt.xlabel(x_label) plt.ylabel(y_label) plt.savefig('build/{}.pdf'.format(filename)) plt.close()
def Plot(x, y, limx, xname, yname, params, name, linear=True, xscale=1, yscale=1, limy=None): xplot = np.linspace(limx[0] * xscale, limx[1] * xscale, 1000) plt.cla() plt.clf() plt.errorbar(noms(x) * xscale, noms(y) * yscale, xerr=stds(x) * xscale, yerr=stds(y) * yscale, fmt='rx', markersize=6, elinewidth=0.5, capsize=2, capthick=0.5, ecolor='g', barsabove=True, label='Wertepaare') if (linear == True): plt.plot(xplot * xscale, Line(xplot, *params) * yscale, 'b-', label='Ausgleichsgerade') plt.xlim(limx[0] * xscale, limx[1] * xscale) if (limy != None): plt.ylim(limy[0] * yscale, limy[1] * yscale) plt.xlabel(xname) plt.ylabel(yname) plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/' + name + '.pdf')
def wellenlaenge(d_array, mitte, L): d_links = unp.uarray(np.zeros(mitte), np.zeros(mitte)) d_rechts = unp.uarray(np.zeros(12-mitte), np.zeros(12-mitte)) for i in range(0, mitte, 1): d_links[i] = np.sum(d_array[mitte-(i+1):mitte]) for i in range(0, 12-mitte, 1): d_rechts[i] = np.sum(d_array[mitte:mitte+(i+1)]) g = (10**-3)/80 print('g = ', g*10**6, 'micro meter') d_links = d_links*10**-2 d_rechts = d_rechts*10**-2 d_all = np.concatenate((noms(d_links), noms(d_rechts))) n_links = np.linspace(1, 6, 6) lamda_links = g * unp.sin(unp.arctan(d_links/L))/n_links n_rechts = range(1, len(d_rechts)+1, 1) n_all = np.concatenate((n_links, n_rechts)) lamda_rechts = g * unp.sin(unp.arctan(d_rechts/L))/n_rechts lamda_all = np.concatenate((lamda_links, lamda_rechts)) werteZuTabelle(d_all*100, n_all.astype(int), (noms(lamda_all)*10**9).astype(int), (stds(lamda_all)*10**9).astype(int), rundungen=[3, 0, 0, 0]) print('lambda = ', (np.sum(lamda_all))/12) print('Abweichung = ', abweichungen(632.8*10**-9, (np.sum(lamda_all))/12)) print('Mittelwert = ', np.mean(noms(lamda_all)), '±', np.std(noms(lamda_all)))
def plotDurchlass(spannung, nu, V_N, amplitude, dateiname): # plt.errorbar(unp.nominal_values(x), unp.nominal_values(y), # xerr=unp.std_devs(x), yerr=unp.std_devs(y), fmt='kx', label='Messwerte') amplitude *= 10**(-3) # abschwächer if V_N is not None: # umrechnen da verschieden verstärkt spannung /= V_N**2 # auf V_N = 1 normieren plt.yscale('log') spannung /= amplitude**2 x = unp.uarray(nu, 0.01) y = unp.uarray(spannung, 0.005) plt.errorbar(unp.nominal_values(x), unp.nominal_values(y), xerr=unp.std_devs(x), yerr=unp.std_devs(y), fmt='kx', label='Messwerte') plt.xlabel(r'$\nu/\si{\kilo\hertz}$') plt.ylabel(r'$U_\text{A}^2 \:/\: \si{\volt\squared}$') plt.legend(loc='best') # in matplotlibrc leider (noch) nicht möglich #plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/plotdurchlass'+dateiname+'.pdf') plt.close() # integration: x *= 10**(3) # auf Hz umrechnen # int = (max(x) - min(x))/len(x) * sum(y) # print("Integral der Durchlasskurve= ", int) int_trapez = trapezFormel(x, y) print("Integral mit trapez = ", int_trapez) int_scipy = integrate.simps(noms(y), x=noms(x)) print("Integral mit scipy = ", int_scipy) int = ufloat(int_scipy, 0) file = open("build/eichung"+dateiname+".txt", "w") file.write(str(int.n)) file.write(" ") file.write(str(int.s)) file.close()
def printScores(pScores, pID): vX = np.linspace(0, 100, len(pScores[0])) if pID == 0: vTitle = 'NaiveBayes' elif pID == 1: vTitle = 'RandomForest' elif pID == 2: vTitle = 'KNN' else: vTitle = 'Default' plt.errorbar(vX, noms(pScores[0]), yerr=stds(pScores[0]), color='g', fmt=',', label='Reinheit') plt.errorbar(vX, noms(pScores[1]), yerr=stds(pScores[1]), color='b', fmt=',', label='Effizienz') plt.plot(vX, noms(pScores[0]), 'g-') plt.plot(vX, noms(pScores[1]), 'b-') plt.ylim(-0.05, 1.05) plt.xlabel('Konfidenzniveau in %', {'size': '16'}) plt.ylabel('Wert', {'size': '16'}) plt.title(vTitle) plt.legend(loc='best', prop={'size': 16}) plt.tight_layout() plt.savefig('Bilder/' + vTitle + '.pdf') plt.show() plt.clf()
def plotphase(nu_1, phi_1, nu_2, phi_2, nu_3, phi_3, nu_4, phi_4): # nu_1, nu_2, nu_3, nu_4 = unp.log(nu_1), unp.log(nu_2), unp.log(nu_3), unp.log(nu_4) # phi_1, phi_2, phi_3, phi_4 = unp.abs(phi_1), unp.abs(phi_2), unp.abs(phi_3), unp.abs(phi_4) plt.errorbar(noms(nu_1), np.abs(noms(phi_1)), xerr=stds(nu_1), yerr=stds(phi_1), label='Messwerte bei 1. Widerstandskombination') plt.errorbar(noms(nu_2), np.abs(noms(phi_2)), xerr=stds(nu_2), yerr=stds(phi_2), label='Messwerte bei 2. Widerstandskombination') plt.errorbar(noms(nu_3), np.abs(noms(phi_3)), xerr=stds(nu_3), yerr=stds(phi_3), label='Messwerte bei 3. Widerstandskombination') plt.errorbar(noms(nu_4), np.abs(noms(phi_4)), xerr=stds(nu_4), yerr=stds(phi_4), label='Messwerte bei 4. Widerstandskombination') xlabel = r'$\nu\:/\:\si{\kilo\hertz}$' ylabel = r'$\phi\:/\:\si{\degree}$' #xlabel = 'test' #ylabel = 'test' plt.xlabel(xlabel) plt.ylabel(ylabel) plt.xscale('log') plt.legend(loc='best') plt.savefig('build/phasen.pdf')
def make_table(columns, figures=None): if figures is None: figures = [None] * len(columns) cols = [] for column, figure in zip(columns, figures): if np.any(stds(column)): if figure is None: figure = '' col = list(zip(*['{0:.{1:}uf}'.format(x, figure).split('+/-') for x in column])) else: col = list(zip(*[['{0:.{1:}f}'.format(x, figure)] for x in noms(column)])) cols.extend(col) max_lens = [max(len(s) for s in col) for col in cols] cols = [['{0:<{1:}}'.format(s, ml) for s in col] for col, ml in zip(cols, max_lens)] rows = list(itertools.zip_longest(*cols)) return (r' \\' + '\n').join([' & '.join(s for s in row if s is not None) for row in rows]) + r' \\'
def make_table(columns, figures=None): if figures is None: figures = [None] * len(columns) cols = [] for column, figure in zip(columns, figures): if (type(column) == str): column = [column] if (type(column) == list): col = zip( *zip(column) ) # hard to find this kind of code... this will unzip the list column, ref: https://docs.python.org/3/library/functions.html#zip cols.extend(col) elif np.any(stds(column)): if figure is None: figure = '' col = list( zip(*[ '{0:.{1:}uf}'.format(x, figure).split('+/-') for x in column ])) else: try: test_iterator = iter( column ) # if only one entry is given, then this will throw a type error exception - handled below col = list( zip(*[['{0:.{1:}f}'.format(x, figure)] for x in noms(column)])) except TypeError: col = list(zip(*[['{0:.{1:}f}'.format(column, figure)]])) cols.extend(col) max_lens = [max(len(s) for s in col) for col in cols] cols = [['{0:<{1:}}'.format(s, ml) for s in col] for col, ml in zip(cols, max_lens)] rows = list(itertools.zip_longest(*cols)) return (r' \\' + '\n').join( [' & '.join(s for s in row if s is not None) for row in rows]) + r' \\'
def fitten(axes, x, y, fitfunktion, p_list, pname_list, color, label, schnittwert=None): params, covariance = curve_fit(fitfunktion, noms(x), noms(y), p0=p_list) errors = np.sqrt(np.diag(covariance)) print('Werte ' + label) for i, name in enumerate(pname_list): print('{0} = {1} ± {2}'.format(name, round(params[i], 5), round(errors[i], 5))) x_fit = np.linspace(noms(x[0]) - (noms(x[-1])) * 1, (noms(x[-1])) * 1.1, 10000) axes.plot(x_fit, fitfunktion(x_fit, *params), color, label='Fit ' + label) if schnittwert is not None: for x_loop in x_fit: if fitfunktion(x_loop, *params) < noms(schnittwert) and params[0] < 0: return unp.exp(x_loop) break elif fitfunktion(x_loop, *params) > noms(schnittwert) and params[0] > 0: return unp.exp(x_loop) break
def make_table(columns, figures=None): assert hasattr(columns[0],'__iter__'), "Wenn nur eine Zeile von Daten vorliegt, funktioniert zip nicht mehr; die Elemente von columns müssen Listen sein, auch wenn sie ihrerseits nur ein Element enthalten." if figures is None: figures = [None] * len(columns) cols = [] for column, figure in zip(columns, figures): if np.any(stds(column)): if figure is None: figure = '' col = list(zip(*['{0:.{1:}uf}'.format(x, figure).split('+/-') for x in column])) else: col = list(zip(*[['{0:.{1:}f}'.format(x, figure)] for x in noms(column)])) cols.extend(col) max_lens = [max(len(s) for s in col) for col in cols] cols = [['{0:<{1:}}'.format(s, ml) for s in col] for col, ml in zip(cols, max_lens)] rows = list(itertools.zip_longest(*cols)) return (r' \\' + '\n').join([' & '.join(s for s in row if s is not None) for row in rows]) + r' \\'
params_gitterkonstante = ucurve_fit( reg_linear, sin_phi_helium, lambda_helium) g, offset = params_gitterkonstante # g in m, offset Einheitenfrei write('build/gitterkonstante.tex', make_SI(g * 1e9, r'\nano\meter', figures=1)) write('build/offset.tex', make_SI(offset * 1e9, r'\nano\meter', figures=1)) write('build/Tabelle_messdaten_kalium.tex', make_table([phi_kalium*180/np.pi],[1])) write('build/Tabelle_messdaten_natrium.tex', make_table([phi_natrium*180/np.pi],[1])) write('build/Tabelle_messdaten_rubidium.tex', make_table([phi_rubidium*180/np.pi],[1])) ##### PLOT lineare Regression ##### t_plot = np.linspace(np.amin(sin_phi_helium), np.amax(sin_phi_helium), 2) plt.xlim(t_plot[0] - 1 / np.size(sin_phi_helium) * (t_plot[-1] - t_plot[0]), t_plot[-1] + 1 / np.size(sin_phi_helium) * (t_plot[-1] - t_plot[0])) plt.plot(t_plot, reg_linear(t_plot, *noms(params_gitterkonstante))* 1e9, 'b-', label='Fit') plt.plot(sin_phi_helium, lambda_helium * 1e9, 'rx', label='Messdaten') plt.ylabel(r'$\lambda \:/\: \si{\nano\meter}$') plt.xlabel(r'$\sin(\varphi)$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/aufgabenteil_a_plot.pdf') plt.clf() #### Ende Plot #### #### TABELLE #### write('build/Tabelle_a.tex', make_table([lambda_helium*1e9, -phi_helium, -sin_phi_helium],[1, 3, 3])) write('build/Tabelle_a_texformat.tex', make_full_table(
def do_job_a(filename, error, j, filename_out=None): # Einlesen der Messdaten P, Delta_f_30, Delta_f_15, Delta_f_60 = np.genfromtxt(filename, unpack=True) # di = [7, 10, 16] colors = ["rx", "bx", "gx"] Delta_f_30_error = Delta_f_30 * error Delta_f_30 = unp.uarray(Delta_f_30, Delta_f_30_error) Delta_f_15_error = Delta_f_15 * error Delta_f_15 = unp.uarray(Delta_f_15, Delta_f_15_error) Delta_f_60_error = Delta_f_60 * error Delta_f_60 = unp.uarray(Delta_f_60, Delta_f_60_error) v = unp.uarray(np.zeros(3), np.zeros(3)) v[0] = c_L / 2 / nu_0 * Delta_f_30 / np.cos(alpha[0]) v[1] = c_L / 2 / nu_0 * Delta_f_15 / np.cos(alpha[1]) v[2] = c_L / 2 / nu_0 * Delta_f_60 / np.cos(alpha[2]) v_mean = mean([v[0], v[1], v[2]], 0) # TABLES write( "build/Tabelle_a_" + str(di[j]) + ".tex", make_table([P, Delta_f_30, Delta_f_15, Delta_f_60, v[0], v[1], v[2], v_mean], [0, 1, 1, 1, 1, 1, 1, 1]), ) write( "build/Tabelle_a_" + str(di[j]) + "_texformat.tex", make_full_table( r"Messdaten und daraus errechnete Geschwindikgiet für $\d_i = $" + str(di[j]) + r"$\si{\milli\meter}$.", "table:A" + str(j), "build/Tabelle_a_" + str(di[j]) + ".tex", [1, 2, 3, 4, 5, 6, 7], [ r"$\frac{P}{P_\text{max}} \:/\: \si{\percent}$", r"$\Delta f_{30°} \:/\: \si{\hertz}$", r"$\Delta f_{15°} \:/\: \si{\hertz}$", r"$\Delta f_{60°} \:/\: \si{\hertz}$", r"$v_{30°} \:/\: \si{\meter\per\second}$", r"$v_{15°} \:/\: \si{\meter\per\second}$", r"$v_{60°} \:/\: \si{\meter\per\second}$", r"$\overline{v} \:/\: \si{\meter\per\second}$", ], ), ) # Plotting plt.figure(1) y = Delta_f_30 / np.cos(alpha[0]) plt.errorbar( noms(v[0]), noms(y), fmt=colors[j], xerr=stds(v[0]), yerr=stds(y), label=r"$d_i = " + str(di[j]) + r"\si{\milli\meter}$", ) plt.figure(2) y = Delta_f_15 / np.cos(alpha[1]) plt.errorbar( noms(v[1]), noms(y), fmt=colors[j], xerr=stds(v[1]), yerr=stds(y), label=r"$d_i = " + str(di[j]) + r"\si{\milli\meter}$", ) plt.figure(3) y = Delta_f_60 / np.cos(alpha[2]) plt.errorbar( noms(v[2]), noms(y), fmt=colors[j], xerr=stds(v[2]), yerr=stds(y), label=r"$d_i = " + str(di[j]) + r"\si{\milli\meter}$", ) i = 1 if filename_out: for name in filename_out: plt.figure(i) plt.xlabel(r"$v \:/\: \si{\meter\per\second}$") plt.ylabel(r"$\Delta\nu / \cos{\alpha} \:/\: \si{\kilo\volt}$") plt.legend(loc="best") plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig(name) i += 1
# write('build1/offset2.tex', make_SI(1e-5*g(373.1, *noms(params_2))-1, r'\bar', '', 1)) # p2 += 1e5-g(373.1, *noms(params_2)) # params_2 = ucurve_fit(g, T2, p2) a2, b2, c2, d2 = params_2 d2 += 48*1e3 # Korrektur Offset (laut Protokoll) write('build1/a2.tex', make_SI(a2 * 1e-5, r'\bar\per\kelvin\tothe{3}', '', 1)) write('build1/b2.tex', make_SI(b2 * 1e-5, r'\bar\per\kelvin\tothe{2}', '', 1)) write('build1/c2.tex', make_SI(c2 * 1e-5, r'\bar\per\kelvin\tothe{1}', '', 1)) write('build1/d2.tex', make_SI(d2 * 1e-5, r'\bar', '', 1)) T_hilf = np.linspace(np.amin(T2), np.amax(T2), 5) T_plot = np.linspace((T_hilf[0]-1/np.size(T2)*(T_hilf[-1]-T_hilf[0])), (T_hilf[-1]+1/np.size(T2)*(T_hilf[-1]-T_hilf[0])), 10) plt.clf() plt.plot(T_plot, g(T_plot, *noms(params_2))*1e-5, 'b-', label='Fit') plt.plot(T2, p2*1e-5, '.r', label='Messdaten') plt.xlim(np.amin(T_plot), np.amax(T_plot)) plt.xlabel(r'$T \:/\: \si{\kelvin}$') plt.ylabel(r'$p \:/\: \si{\bar}$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build1/plot2.pdf') plt.clf() T_plot = np.linspace(200,600,100) plt.plot(T_plot, L(0.9, R[0], T_plot, *noms(params_2)), 'b-', label='Fit numpy curve_fit') plt.plot(T_plot, L(0.9, R[0], T_plot, 4.32*1e-1, -4.07*1e2, 1.262*1e5, -127.82*1e5+48*1e3), 'r-', label='Fit Origin 8') #plt.plot(T2, p2*1e-5, '.r', label='Messdaten')
U_1, I_1 = np.loadtxt("Messdaten/I_aU_a_I.txt", unpack=True) # Fehler u_err = 0.05 # Volt pro Millimeter i_err = 0.1 # Zentimeter U_1_err = unp.uarray(U_1, [u_err]*len(U_1)) I_1_err = unp.uarray(I_1, [i_err]*len(U_1)) dU_1_err = [(U_1_err[i+1] - U_1_err[i]) for i in range(len(I_1_err)-1)] dI_1_err = [(I_1_err[i] - I_1_err[i+1]) for i in range(len(I_1)-1)] print("Maximum:", U_1_err[np.where(noms(dI_1_err) == max(noms(dI_1_err)))[0][0]], "/", max(dI_1_err)) print("Kontaktpotenzial:", ufloat(11, 1) - U_1_err[np.where(noms(dI_1_err) == max(noms(dI_1_err)))[0][0]]) K_1_err = ufloat(11, 1) - U_1_err[np.where(noms(dI_1_err) == max(noms(dI_1_err)))[0][0]] plt.plot(noms(U_1_err[:-1]), noms(dI_1_err), label="differenzielle\nEnergieverteilung") plt.stem([noms(U_1_err[np.where(noms(dI_1_err) == max(noms(dI_1_err)))[0][0]])], [max(noms(dI_1_err))], linefmt="k--", markerfmt="ko", label="max. Änderung ({}|{})".format(U_1[np.where(noms(dI_1_err) == max(noms(dI_1_err)))[0][0]], max(noms(dI_1_err)))) plt.grid() plt.xlabel(r"Bremsspannung $U_{A}$") plt.ylabel("Änderung des Auffängerstroms\n $I_{A}(U_{A}) - I_{A}(U_{A} + \Delta U_{A})$") plt.legend(loc="upper left") #plt.show() plt.savefig("Grafiken/Diff_EVerteilung_20.pdf")
#Fit # y2 = 1/T**2 # params2 = ucurve_fit(reg.reg_linear, B, y2) # m2,D2 = params2 # # m2 *= 4*np.pi**2*(Theta_Kugel+Theta_Aufhaengung) # write('build/m2.tex', make_SI(m2*1e3, r'\ampere\square\meter', 'e-3', figures=1)) # write('build/D2.tex', make_SI(D2*1e5, r'\kilogram\square\meter\per\square\second', 'e-5', figures=1)) y = 4*np.pi**2*(Theta_Kugel+Theta_Aufhaengung)/T**2 params = ucurve_fit(reg.reg_linear, B, y) # linearer Fit m, D = params write('build/m.tex', make_SI(m*1e3, r'\ampere\square\meter', 'e-3', figures=1)) write('build/D.tex', make_SI(D*1e5, r'\kilogram\square\meter\per\square\second', 'e-5', figures=1)) # D = 4*(np.pi**2)*(Theta_Kugel+Theta_Aufhaengung)/(T**2) m_th = 1/B * (4*(np.pi**2) * (Theta_Kugel+Theta_Aufhaengung) / T**2 - D_ohneB) m_th_unc = ufloat(np.mean(noms(m_th)), MeanError(noms(m_th))) write('build/m_th.tex', make_SI(m_th_unc*1e3, r'\ampere\square\meter', 'e-3', figures=1)) # print(m_th) t_plot = np.linspace(np.amin(B), np.amax(B), 100) # plt.plot(t_plot*1e3, reg.reg_linear(t_plot, *noms(params))*1e5, 'b-', label='Methode 1') plt.plot(t_plot*1e3, reg.reg_linear(t_plot, np.mean(noms(m_th)), np.mean(noms(D)))*1e5, 'g-', label='Methode 2') # plt.plot(B * 1e3, noms(y)*1e5, 'rx', label='Messdaten') plt.errorbar(B * 1e3, noms(y) * 1e5, fmt='r.', yerr=stds(y) * 1e5, label='Messdaten') ## plt.xscale('log') # logarithmische x-Achse plt.xlim((t_plot[0]-1/np.size(B)*(t_plot[-1]-t_plot[0]))*1e3, (t_plot[-1]+1/np.size(B)*(t_plot[-1]-t_plot[0]))*1e3) plt.xlabel(r'$B \:/\: \SI{e-3}{\tesla}$') plt.ylabel(r'$\frac{4\pi^2 \Theta_\text{Gesamt}}{T^2} \:/\: \SI{e-5}{\kilogram\square\meter\per\square\second}$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08)
Begin der Auswertung zum Dopplereffekt """ # Laden der Daten zur Bestimmung der Geschwindigkeit ## Laden der Strecke l = np.loadtxt("Messdaten/Strecke.txt", unpack=True) l_err = np.loadtxt("Messdaten/Fehler_Strecke.txt") ### Fehler behaftete Messwerte ul = unp.uarray(l, [l_err]*len(l)) ### Mittelwert ul_avr = Umean(ul) ul_avr = ufloat(noms(ul_avr), stds(ul_avr)) ul_avr *= 1e-02 # [cm] --> [m] ## Laden der Zeiten in den verschiedenen Gängen G, t_h1, t_h2, t_r1, t_r2 = np.loadtxt("Messdaten/Zeiten.txt", unpack=True) t_err = np.loadtxt("Messdaten/Fehler_Zeiten.txt") ### Fehlerbehaftete Messwerte ut_h1 = unp.uarray(t_h1, [t_err]*len(t_h1)) ut_h2 = unp.uarray(t_h2, [t_err]*len(t_h2)) ut_r1 = unp.uarray(t_r1, [t_err]*len(t_r1)) ut_r2 = unp.uarray(t_r2, [t_err]*len(t_r2)) ### Mittelwerte der Zeiten uT_h_avr = unp.uarray(np.zeros(len(G)), np.zeros(len(G)))
from linregress import ulinregress Delta_t_0 = np.loadtxt('Delta_t_0.txt') N_0 = np.loadtxt('N_0.txt') N_0 = unc.ufloat(N_0, np.sqrt(N_0)) Delta_t = np.loadtxt('Delta_t.txt') N_g = np.loadtxt('N_g.txt', unpack=True) N_g = unp.uarray(N_g, np.sqrt(N_g)) t = Delta_t * np.arange(1, len(N_g) + 1) N = N_g - N_0 / Delta_t_0 * Delta_t A, B = ulinregress(t, unp.log(N)) print(A, B, sep='\n') lambda_ = -A print("λ =", lambda_) x = np.linspace(0, 4000) plt.plot(x, np.exp(noms(A * x + B)), 'b-', label='Regressionsgerade') plt.errorbar(t, noms(N), yerr=stds(N), fmt='rx', label='Messwerte') plt.yscale('log', nonposy='clip') plt.xlabel(r'$t \,/\, \mathrm{s}$') plt.ylabel(r'$N$') plt.ylim(8e2, 3e3) plt.yticks([8e2, 1e3, 3e3], [r"$8 \cdot 10^2$", r"$10^3$", r"$3 \cdot 10^3$"]) plt.legend(loc='upper right') plt.tight_layout() plt.savefig('loesung.pdf')
#plt.show() plt.clf() # Subtraktion der Langlebigen Zerfälle N_Rh_lang = np.array(np.exp(-popt_Rh_2[0]*T_Rh[:10])*exp(popt_Rh_2[1])) #print(N_Rh_lang) # Fehler der Werte n_Rh_lang_err = np.array([m.sqrt(x) for x in N_Rh_lang]) # Fehlerbehaftete Größe N_Rh_lang_err = unp.uarray(N_Rh_lang, n_Rh_lang_err) N_Rh_kurz_err= np.array(np.subtract(N_Rh_err[:10], N_Rh_lang_err)) #print(N_Rh_kurz_err) lnN_Rh_kurz = np.array([m.log(x) for x in noms(N_Rh_kurz_err)]) #print(lnN_Rh_kurz) # Regression kurzlebig popt_Rh_1, pcov_Rh_1 = curve_fit(f_gerade, T_Rh[:10], lnN_Rh_kurz) #sigma=stds(N_Rh_kurz_err)/noms(N_Rh_kurz_err)) errors_Rh_1 = np.sqrt(np.diag(pcov_Rh_1)) param_a_Rh_1 = ufloat(popt_Rh_1[0], errors_Rh_1[0]) param_b_Rh_1 = ufloat(popt_Rh_1[1], errors_Rh_1[1]) print("Parameter Exp. Regression a,b :", param_a_Rh_1, param_b_Rh_1) # Plot der Messwerte für t < t*
def geradeF(x, b): return noms(param_VI_g_M) * x + b
Ip_calc = uY_p/R Im_calc = uY_m/R n = 1 for c in uC3: plt.clf() plt.grid() plt.tick_params("both", labelsize=16) plt.xlabel("Frequenz $f\,[\mathrm{kHz}]$", fontsize=16) plt.xlim(2e04, 6e04) plt.gca().xaxis.set_major_formatter(mpl.ticker.FuncFormatter (lambda x, _: float(x * 1e-03))) plt.gca().yaxis.set_major_formatter(mpl.ticker.FuncFormatter (lambda x, _: float(x * 1e03))) plt.ylabel("Stromstärke $I\,[\mathrm{mA}]$", fontsize=16) plt.plot(Xrange, noms(Strom(4, Xrange * 2 * const.pi, uC, c, R, uL))) plt.savefig("Grafiken/Stromverlauf{}.pdf".format(str(n))) n += 1 plt.clf() plt.grid() plt.xlabel("Frequenz $f\,[\mathrm{kHz}]$") plt.xlim(2e04, 6e04) plt.gca().xaxis.set_major_formatter(mpl.ticker.FuncFormatter (lambda x, _: float(x * 1e-03))) plt.ylabel("Stromstärke $I\,[\mathrm{A}]$") plt.plot(Xrange, noms(Strom(4, Xrange * 2 * const.pi, uC, uC3[0], R, uL))) ### Noch ein paar Plots plt.clf()
write('build/Abschirmkonstante_Zink.tex', make_SI(sigma_zink, r' ', figures=2)) write('build/Abschirmkonstante_Zirkonium.tex', make_SI(sigma_zir, r' ', figures=2)) #Moseley-Diagramm E_k = (E_zink, E_ger, E_zir) Z = (30,32,40) # Zn, Ge, Zr E_k_wurzel = np.sqrt(E_k) params = ucurve_fit(reg_linear, Z, E_k_wurzel) m,b = params write('build/hcRydbergonstante.tex', make_SI(4/3*m**2, r'\electronvolt', figures=1)) write('build/Rydbergonstante.tex', make_SI(4/3*m**2/(h*c), r'\per\meter', figures=1)) plt.clf t_plot = np.linspace(25,45, 100) plt.plot(t_plot , reg_linear(t_plot, *noms(params)), 'b-', label='Fit') plt.plot(Z, E_k_wurzel, 'rx', label='Messdaten') plt.xlabel(r'Kernladungszahl $Z$') plt.ylabel(r'$\sqrt{E_\textrm{k} \:/\: \si{\kilo\electronvolt}}$') plt.legend(loc='best') plt.savefig("build/Moseley_Diagramm.pdf") plt.close ################################ FREQUENTLY USED CODE ################################ # ########## IMPORT ########## # t, U, U_err = np.genfromtxt('data.txt', unpack=True) # t *= 1e-3 ########## ERRORS ##########
m_g=107.67 m_gw=465.18# Tgw=293.40 Tgm=296.63 Tg=352.19 ckz=ck(m_zw,m_z,Tzm,Tzw,Tz) ckg=ck(m_gw,m_g,Tgm,Tgw,Tg) #ckg=ck(465.18,107.67,295.63,293.40,352.19) ckz=unp.uarray(np.average(ckz),np.std(ckz)) Tzm=np.average(Tzm) print('Abweichung von ckz',ab(noms(ckz),0.23)) print('Abweichung von ckg',ab(ckg,0.715)) print('ckz',ckz) print('ckg',ckg) Cz=C(ckz,Molz,az,kz,rhoz,Tzm) Cg=C(ckg,Molg,ag,kg,rhog,Tgm) print('Cz',Cz) print('Cg',Cg) print('3R',3*8.3144598) print('Abweichung von 3R z',ab(noms(Cz),3*8.3144598)) print('Abweichung von 3R g',ab(Cg,3*8.3144598)) #print(ckz)
s_ds_mic *= scale_mic * 1e-3 # in m ############# STARTING FITS ################## plot_it = True #### KLEINER EINZELSPALT #### zeta_0_k = zeta_0[0] # in m phi_k = phi1 - zeta_0_k/L # in rad phi_k_plot = phi1_plot - zeta_0_k/L # in rad params_k = ucurve_fit(theory_einfach, phi_k, I_k, p0=[np.sqrt(max(I_k)) / b_k_hst, b_k_hst]) A0_k, b_k = params_k if (plot_it): plt.clf() plt.plot(phi1_plot*1e3, theory_einfach(phi_k_plot, *noms(params_k))*1e6, 'b-', label='Fit') plt.plot(phi1*1e3, I_k*1e6, 'rx', label='Messdaten') plt.xlabel(r'$\varphi \:/\: \si{\milli\radian}$') plt.ylabel(r'$I \:/\: \si{\micro\ampere}$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/plot_klein.pdf') #### MITTLERER EINZELSPALT #### zeta_0_m = zeta_0[1] # in m phi_m = phi1 - zeta_0_m/L phi_m_plot = phi1_plot - zeta_0_m/L params_m = ucurve_fit(theory_einfach, phi_m, I_m, p0=[np.sqrt(max(I_m)) / b_m_hst, b_m_hst]) A0_m, b_m = params_m
#N_zu I_s1=3.110 I_s2=2.440 I_s3=1.294 I_s4=0.721 I_s5=0.250 Austritt_1=-unp.log((I_s1/f)*(const.h**3)/(const.e*const.m_e*(const.k**2)*(T_w1**2)))*const.k*T_w1/const.e Austritt_2=-unp.log((I_s2/f)*(const.h**3)/(const.e*const.m_e*(const.k**2)*(T_w2**2)))*const.k*T_w2/const.e Austritt_3=-unp.log((I_s3/f)*(const.h**3)/(const.e*const.m_e*(const.k**2)*(T_w3**2)))*const.k*T_w3/const.e Austritt_4=-unp.log((I_s4/f)*(const.h**3)/(const.e*const.m_e*(const.k**2)*(T_w4**2)))*const.k*T_w4/const.e Austritt_5=-unp.log((I_s5/f)*(const.h**3)/(const.e*const.m_e*(const.k**2)*(T_w5**2)))*const.k*T_w5/const.e #Austritt_Leistung=-unp.log((I_s1/f)*(const.h**3)/(const.e*const.m_e*(const.k**2)*(T_w1**2)))*const.k*T_w1/const.e print('Austritt_1',Austritt_1) print('Austritt_2',Austritt_2) print('Austritt_3',Austritt_3) print('Austritt_4',Austritt_4) print('Austritt_5',Austritt_5) print('Mittelwert normal',np.mean([Austritt_1,Austritt_2,Austritt_3,Austritt_4,Austritt_5]),'+-',np.std([noms(Austritt_1),noms(Austritt_2),noms(Austritt_3),noms(Austritt_4),noms(Austritt_5)])) #print('Mittelwert np',np.mean([Austritt_2,Austritt_1]),'+-',np.std([noms(Austritt_2),noms(Austritt_1)]))
R_a, Offset_a = params_max print('R_a') print(R_a) R_a_2 = R_a*(-2*10.11e-3) R_dampf_theo = 2*(unp.sqrt(L[0]/C[0])) print('hhhhhhh') print(L[0]) print(C[0]) write('build/R_daempfung_theo.tex', make_SI(R_1[0], r'\ohm', figures=1)) write('build/R_daempfung_mess.tex', make_SI(R_a_2, r'\ohm', figures=1)) # type in Anz. signifikanter Stellen write('build/R_abweichung.tex', make_SI(R_a_2-R_1[0], r'\ohm', figures=1)) # write('build/loesung-b.tex', make_SI(b * 1e-3, r'\kilo\hertz', figures=1)) # Abklingzeit ausrechnen Abklingzeit_max = np.log(np.max(Umax)/np.exp(1)/noms(Offset_a)) / R_a Abklingzeit_theo = 2*L[0] / R_1[0] write('build/Abklingzeit_theo.tex', make_SI(Abklingzeit_theo*1e3, r'\milli\second', figures=1)) write('build/Abklingzeit_mess.tex', make_SI(Abklingzeit_max*(-1e3), r'\milli\second', figures=1)) write('build/Abklingzeit_abweichung.tex', make_SI(-Abklingzeit_max*(-1e3)+Abklingzeit_theo*1e3, r'\milli\second', figures=1)) # plt.plot(tmax*1e3, Umax, 'rx', label='Messdaten') # plt.plot(tmax*1e3, np.exp(noms(Offset_a)+tmax*noms(R_a)), 'b-', label='Fit') plt.plot(text*1e3, np.abs(Uext), 'rx', label='Messdaten') plt.plot(text*1e3, np.exp(noms(Offset_a)+text*noms(R_a)), 'b-', label='Fit') plt.ylabel(r'$U \:/\: \si{\volt}$') plt.xlabel(r'$t \:/\: \si{\milli\second}$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/moin_1.pdf')
plt.xlabel(r'$\mathrm{Ablenkspannung \ U_d/V}$') plt.ylabel(r'$\mathrm{Verschiebung \ D/m}$') plt.savefig('plotV5012.pdf') np.savetxt('1tabelle.txt', np.column_stack((D_U1, Ud1, Ud2, Ud3)), fmt='%r', delimiter=' & ') Mges = unp.uarray( [m1, m2, m3, m4, m5], [stds(M1), stds(M2), stds(M3), stds(M4), stds(M5)]) Ubges = np.array([Ub1, Ub2, Ub3, Ub4, Ub5]) print(noms(Mges)) ma, ba, ra, pa, stda = stats.linregress(1 / Ubges, noms(Mges)) x_ub = np.linspace(0, 0.006) plt.figure(3) plt.plot(1 / Ubges, noms(Mges), 'rx', label=r'$\mathrm{Messwerte}$') plt.errorbar(1 / Ubges, noms(Mges), xerr=0, yerr=stds(Mges), fmt='rx') plt.plot(x_ub, ma * x_ub + ba, 'c-', label=r'$\mathrm{Ausgleichsfunkion}$') plt.legend(loc='best') plt.xlabel(r'$\mathrm{U_b^{-1}/V^{-1}}$') plt.ylabel(r'$D\,U_d^{-1}\mathrm{/m V^{-1} }$') plt.savefig('plotV501a.pdf') Ma = unp.uarray(ma, stda) Ba = unp.uarray(ba, fehler_b(stda, 1 / Ubges))
# # plt.plot(t_plot, reg.reg_linear(t_plot, *noms(params)), 'b-', label='Fit') # plt.xlim(t_plot[0], t_plot[-1]) # # plt.xlabel(r'$t \:/\: \si{\milli\second}$') # # plt.ylabel(r'$U \:/\: \si{\kilo\volt}$') # plt.legend(loc='best') # plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) # plt.savefig('build/test-plot.pdf') # Ablesen der Grenzfrequenzen und Umrechnen f_gr = 9 f_gr1 = 5.60 f_gr2 = 14.73 f_gr3 = 18.15 f_gr = np.exp(reg.reg_linear(f_gr, noms(m1), noms(b1))) f_gr1 = np.exp(reg.reg_linear(f_gr1, noms(m2), noms(b2))) f_gr2 = np.exp(reg.reg_linear(f_gr2, noms(m2), noms(b2))) f_gr3 = np.exp(reg.reg_linear(f_gr3, noms(m2), noms(b2))) write('build/Z_w_gr.tex', make_SI(Wellenwiderstand(2*np.pi*f_gr), r'\ohm', figures=0)) write('build/f_mess.tex', make_SI(f_gr*1e-3, r'\kilo\hertz', 'e-3',figures=1)) write('build/f1_mess.tex', make_SI(f_gr1*1e-3, r'\kilo\hertz', 'e-3',figures=1)) write('build/f2_mess.tex', make_SI(f_gr2*1e-3, r'\kilo\hertz', 'e-3',figures=1)) write('build/f3_mess.tex', make_SI(f_gr3*1e-3, r'\kilo\hertz', 'e-3',figures=1)) # Theoriewerte der Grenzfrequenzen w_th = 2 / np.sqrt(L*C1) w1_th = np.sqrt(2/(L*C1)) w2_th = np.sqrt(2/(L*C2)) w3_th = np.sqrt( 2/L * (C1+C2)/(C1*C2) )
#Messung 2 def Brech(z,lamb,T,p0,b,T0,deltaP): n=1+z*lamb*T*p0/(2*b*T0*deltaP) return n p1,p2,ticks =np.genfromtxt('Messung2.txt', unpack = True) deltaP=p2-p1 p0=1.0132 T0=273.15 b=50e-3 T=293.15 n=unp.uarray(noms(Brech(ticks,L,T,p0,b,T0,deltaP)),stds(Brech(ticks,L,T,p0,b,T0,deltaP))) # n=Brech(ticks,L,T,p0,b,T0,deltaP) print(n,'n Luft') print(np.mean(noms(n)),stats.sem(noms(n)),'Luft np.mean(noms(n)),stats.sem(noms(n))') nL=ufloat(np.mean(noms(n)),stats.sem(noms(n))) #Messung3 p1,p2,ticks =np.genfromtxt('Messung3.txt', unpack = True) deltaP=p2-p1 n=unp.uarray(noms(Brech(ticks,L,T,p0,b,T0,deltaP)),stds(Brech(ticks,L,T,p0,b,T0,deltaP))) print(n,'n 1-Butylen')
v_8_0 = 88 # s/mm U_8 = 185 v_9_auf, v_9_ab = np.genfromtxt('messdaten/9_Tropfen.txt', unpack=True) v_9_auf_mittel = ufloat(np.mean(v_9_auf), np.std(v_9_auf)) # s/mm v_9_ab_mittel = ufloat(np.mean(v_9_ab), np.std(v_9_ab)) # s/mm v_9_0 = 112 # s/mm U_9 = 184 v_10_auf, v_10_ab = np.genfromtxt('messdaten/10_Tropfen.txt', unpack=True) v_10_auf_mittel = ufloat(np.mean(v_10_auf), np.std(v_10_auf)) # s/mm v_10_ab_mittel = ufloat(np.mean(v_10_ab), np.std(v_10_ab)) # s/mm v_10_0 = 59.4 # s/mm U_10 = 286 v_auf_mittel_nom=[ noms(v_2_auf_mittel), noms(v_3_auf_mittel), noms(v_4_auf_mittel), noms(v_5_auf_mittel), noms(v_6_auf_mittel), noms(v_7_auf_mittel), noms(v_8_auf_mittel), noms(v_9_auf_mittel), noms(v_10_auf_mittel)] v_auf_mittel_stds=[ stds(v_2_auf_mittel), stds(v_3_auf_mittel), stds(v_4_auf_mittel), stds(v_5_auf_mittel), stds(v_6_auf_mittel), stds(v_7_auf_mittel), stds(v_8_auf_mittel), stds(v_9_auf_mittel), stds(v_10_auf_mittel)] v_ab_mittel_nom=[ noms(v_2_ab_mittel), noms(v_3_ab_mittel), noms(v_4_ab_mittel), noms(v_5_ab_mittel), noms(v_6_ab_mittel), noms(v_7_ab_mittel), noms(v_8_ab_mittel), noms(v_9_ab_mittel), noms(v_10_ab_mittel)] v_ab_mittel_stds=[ stds(v_2_ab_mittel), stds(v_3_ab_mittel), stds(v_4_ab_mittel), stds(v_5_ab_mittel), stds(v_6_ab_mittel), stds(v_7_ab_mittel), stds(v_8_ab_mittel), stds(v_9_ab_mittel), stds(v_10_ab_mittel)] # v_0 = array(1/v_2_0, 1/v_3_0, 1/v_4_0, 1/v_5_0, 1/v_6_0, 1/v_7_0, 1/v_8_0, 1/v_9_0, 1/v_10_0) v_0 = np.genfromtxt('messdaten/V_0.txt', unpack=True) v_0 = 1/v_0 U = np.genfromtxt('messdaten/Spannung.txt', unpack=True) v_auf = unp.uarray(v_auf_mittel_nom, v_auf_mittel_stds) v_auf = 1/v_auf v_ab = unp.uarray(v_ab_mittel_nom, v_ab_mittel_stds) v_ab = 1/v_ab
print("Eta, bestimmt mit der kleinen Kugel, ist in Pa*sec:") print(etaK) print("Mit diesem Eta ist die Apparaturkonstante in willkuerlichen Einheiten:") print(apparatG) print("") print("Viskositaet in Pa*sec:") print(etaG_2) print("") print("Viskositaet in mPa*sec, vgl. Literatur:") print(etaG_2*1000) print("") print("Geschwindigkeiten in m/s:") print((0.1/fallzeit)) print("") print("Reynoldzahlen:") print(Re) np.savetxt("Auswertung/Viskositaeten.txt", np.array([noms(etaG_2),stds(etaG_2)]).T) np.savetxt("Auswertung/Reynoldzahlen.txt", np.array([noms(Re),stds(Re)]).T) np.savetxt("Auswertung/Geschwindigkeiten.txt", np.array([noms((0.1/fallzeit)),stds((0.1/fallzeit))]).T) np.savetxt("Auswertung/Zeiten.txt", np.array([noms((fallzeit)),stds((fallzeit))]).T)
# Umrechnung der Messwerte L_1_off_err = L_1_err[:] L_1_err = AbstandOhneOffset(L_1_err) #print("Abstände ohne", L_1_err) # Laden der Intensitäten, l nicht gebraucht l , J_1 = np.loadtxt("Messdaten/Abstand_Intensitaet_1.txt", unpack=True) # Fehlerbehaftete Intensitäten J_1_err = unp.uarray(J_1, [j_err1 if J_1[i] < 10 else j_err2 for i in range(len(J_1))]) # Auftragen des Stroms gegen die Intensität # linearer Fit der Messwerte func_gerade = lambda x,a,b: a*x+b popt_1, pcov_1 = curve_fit(func_gerade, noms(J_1_err), noms(I_k_1_err)) error_1 = np.sqrt(np.diag(pcov_1)) param_a_1 = ufloat(popt_1[0], error_1[0]) param_b_1 = ufloat(popt_1[1], error_1[1]) print("Kurzschlussstrom-Fit:") print("Steigung:", param_a_1) print("Y-Achsenabschnitt:", param_b_1) # Plot der Wertepaare (J/I) plt.plot(noms(J_1_err), noms(I_k_1_err), "xr", label="Messwerte") # Plot der Fit-Gerade X = np.linspace(1,30, 300) plt.plot(X, func_gerade(X, *popt_1), color="gray", label="Regressionsgerade")
t, u_c = np.genfromtxt('a.txt', unpack=True) U_c=unp.uarray(u_c,0.05) T=unp.uarray(t,0.05) U_0=unp.uarray(19.4,0.05) y=1-(U_c/U_0) #phi=(a/b)*2*np.pi #plt.figure(1) #plt.plot(1/(b*10**-3),phi,'rx') #plt.savefig('plot.pdf') print(T) index= [12,13] Tt=np.delete(T, index) print(Tt) yy=np.delete(y, index) m , b , r ,p ,std =stats.linregress(noms(Tt),np.log(noms(yy))) print('m', m) plt.figure(1) plt.errorbar(t ,noms(y),xerr=stds(T),yerr=stds(y), fmt='rx') plt.plot(noms(T),noms(y),'kx',label=r'$Messwerte$') x=np.linspace(0,5) plt.plot(t, np.exp(m*t+b),label=r'$Ausgleichsfunktion$') plt.yscale('log') plt.legend(loc='best') plt.xlabel(r'$t/s$') plt.ylabel(r'$ln(1-(U_c/U_0)) $') plt.savefig('a.pdf') M=unp.uarray(m,std) print('RC ist = ', 1/M, M) print('Delta Rc',std/m**2)
gv = unp.uarray #Geschw. vorwärts gr = unp.uarray #Geschw. rückwärts for v in V: v *= 1.25e-4 #Zählwerkverzögerung gv = np.append(gv, np.mean(v)) gv = gv[1:] gv = s / gv for r in R: r *= 1.25e-4 #Zählwerkverzögerung gr = np.append(gr, np.mean(r)) gr = gr[1:] gr = s / gr x = np.linspace(1, 10, num=10) np.savetxt('GangGeschwVorRueck4Tab.txt', np.column_stack([x, noms(gv), stds(gv), -noms(gr), stds(gr)]), delimiter=' & ', newline=r' \\' '\n ') np.savetxt('GeschwVorRueck.txt', np.column_stack([noms(gv), stds(gv), -noms(gr), stds(gr)])) # # x= np.linspace(1,10,num=10) # np.savetxt('GeschwMittelproGang.txt',y,header='#inMeterproSekund') # # Plot der Geschw. im arith. Mittel # plt.plot(x , y,'rx', label='arith. Mittel der gemessenen Geschwindigkeiten') # plt.xlabel(r'$ Gäng\;der\; Versuchsapparatur$')
def main(): args = parse_args() config = parse_config(args.config_file) if config is None: print('No configuration file is defined. ' 'Define one with `--config-file`.') sys.exit(1) # read dataset files = config['files'] if 'filepath' in config: files = [config['filepath'] + f for f in files] kwargs = config['pandas_kwargs'] print('Reading ', end='') entries = 0 for f in files: rootfile = ROOT.TFile(f) tree = rootfile.Get(kwargs['key']) entries += tree.GetEntries() maxslices = args.max_slices chunksize = kwargs['chunksize'] total = (maxslices if maxslices is not None and maxslices < (entries / chunksize) else (entries / chunksize)) print(total * chunksize, 'events.') df = pd.concat([ df for df in tqdm( islice( read_root(files, flatten=True, **kwargs), maxslices), total=total)]) # rename the tagging particle branches df.rename(columns=dict(zip(df.columns, [c.replace(config['tagging_particle_prefix'], 'tp').replace('-', '_') for c in df.columns])), inplace=True) df['event_id'] = df.runNumber.apply(str) + '_' + df.eventNumber.apply(str) if 'invert_target' in config and config['invert_target']: df['target'] = np.sign(df.B_ID) != np.sign(df.tp_ID) else: df['target'] = np.sign(df.B_ID) == np.sign(df.tp_ID) # read features and selections try: if 'inclusive_mva_features' in config: mva_features = ['tp_' + f for f in config['inclusive_mva_features']] else: mva_features = ['tp_' + f.split(' ')[0] for f in config['selections']] except: raise ValueError('Tried to parse features for the BDT.' ' Either provide well-formatted `selections` or' ' define a `inclusive_mva_features` set.') # build BDT model and train the classifier n_cv x 3 times xgb_kwargs = config['xgb_kwargs'] n_jobs = config['n_jobs'] bootstrap_scores = [] bootstrap_d2s = [] nfold = (args.bootstrap_folds if args.bootstrap_folds is not None else config['n_cv']) print('Starting bootstrapping.') pbar = tqdm(total=nfold * 3) for _ in range(nfold): # yield 3-fold split for CV df_sets = [df.iloc[indices] for indices in NSplit(df)] cv_scores = [] for i in range(3): df1, df2, df3 = (df_sets[i % 3].copy(), df_sets[(i + 1) % 3].copy(), df_sets[(i + 2) % 3].copy()) model = XGBClassifier(nthread=n_jobs, **xgb_kwargs) sample_weight = (df1.target if 'training_weights' in config and config['training_weights'] else None) model.fit(df1[mva_features], df1.target, sample_weight=df1.SigYield_sw) df2['probas'] = model.predict_proba(df2[mva_features])[:, 1] df2.reset_index(inplace=True, drop=True) df2_max = df2.iloc[df2.groupby('event_id')['probas'].idxmax()].copy() df3['probas'] = model.predict_proba(df3[mva_features])[:, 1] df3.reset_index(inplace=True, drop=True) df3_max = df3.iloc[df3.groupby('event_id')['probas'].idxmax()].copy() # calibrate calibrator = PolynomialLogisticRegression(power=4, solver='lbfgs', n_jobs=n_jobs) calibrator.fit(df2_max.probas.reshape(-1, 1), df2_max.target, sample_weight=df2_max.SigYield_sw) df3_max['calib_probas'] = calibrator.predict_proba(df3_max.probas)[:, 1] score = tagging_power_score(df3_max.calib_probas, tot_event_number=get_event_number(df3_max), sample_weight=df3_max.SigYield_sw) bootstrap_scores.append(score) bootstrap_d2s.append(d2_score(df3_max.calib_probas, sample_weight=df3_max.SigYield_sw)) pbar.update(1) pbar.close() print(dedent("""\ Final {}-fold bootstrap performance D2 = {:<6}% ε_eff = {:<6}%""") .format(nfold, 100 * ufloat(np.mean(bootstrap_d2s), np.std(bootstrap_d2s)), 100 * ufloat(np.mean(noms(bootstrap_scores)), np.std(noms(bootstrap_scores)))))
for i in range(xmin,xmax): # going thru all col content = [] error = [] x_value.append(i) y_value.append(0) for j in range(ymin,ymax): # going thru all rows content.append( qMap_Ag_C0_V0.GetBinContent(i,j)) error.append( qMap_Ag_C0_V0.GetBinError(i,j)) # Is this the real error content_bin = unp.uarray( content, error) mean_content_col = content_bin.mean() # mean value of each bin in the col # Saving values in lists mean_value_col_list.append( noms(mean_content_col)) mean_error_col_list.append( stds(mean_content_col)) ########################### Create errorbar plot ##################################### errorbar_plot_col = root.TGraphErrors( len(x_value), array( 'f', x_value), array( 'f', mean_value_col_list), array( 'f', y_value), array( 'f', mean_error_col_list) ) ############################## Set axis label of errobar plot ################################## errorbar_plot_col.GetXaxis().SetTitle("Col") errorbar_plot_col.GetYaxis().SetTitle("Mean Hit / Vcal") ####################### create Canvas ########################################## c1 = root.TCanvas("c1", "c1", 1980, 1080)
def do_job_b(filename, error, P, limits): # Einlesen der Messdaten Tiefe, Delta_f, Intensity = np.genfromtxt(filename, unpack=True) colors = ["rx", "bx", "gx"] Delta_f_error = Delta_f * error Delta_f = unp.uarray(Delta_f, Delta_f_error) v = c_L / 2 / nu_0 * Delta_f / np.cos(alpha[1]) # 15 ° Winkel ###### Fit im Intervall limits mit quadratischer Funktion gemäß dem Gesetz von Hagen-Poiseuille i = 0 start = 0 end = 0 for x in Tiefe: if x == limits[0]: start = i if x == limits[1]: end = i i += 1 params = ucurve_fit(reg_quadratic, Tiefe[start : (end + 1)], v[start : (end + 1)]) # quadratischer Fit a, x0, c = params write("build/parameter_a.tex", make_SI(a * 1e-3, r"\kilo\volt", figures=1)) ##### Ende Fit ######## # Plotting plt.clf fig, ax1 = plt.subplots() t_plot = np.linspace(limits[0] - 0.5, limits[1] + 0.5, 50) # Momentangeschwindigkeiten Ins1 = ax1.plot(Tiefe, noms(v), "rx", label="Momentangeschwindigkeit") Ins2 = ax1.plot(t_plot, reg_quadratic(t_plot, *noms(params)), "r--", label="Fit") ax1.set_xlabel(r"$\text{Laufzeit} \:/\: \si{\micro\second}$") ax1.set_ylabel(r"$v \:/\: \si{\meter\per\second}$") if P == 45: ax1.set_ylim(0.45, 0.9) # hard coded stuff ftl ! # Streuintensitäten ax2 = ax1.twinx() Ins3 = ax2.plot(Tiefe, Intensity, "b+", label="Intensität") ax2.set_ylabel(r"$I \:/\: \si{\kilo\volt\squared\per\second}$") # Theoretische Grenzen des Rohres einzeichnen ax1.plot((noms(x0) - 5 / 1.5, noms(x0) - 5 / 1.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1) ax1.plot((noms(x0) + 5 / 1.5, noms(x0) + 5 / 1.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1) ax1.plot( (noms(x0) - 5 / 1.5 - 2.5 / 2.5, noms(x0) - 5 / 1.5 - 2.5 / 2.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1, ) ax1.plot( (noms(x0) + 5 / 1.5 + 2.5 / 2.5, noms(x0) + 5 / 1.5 + 2.5 / 2.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1, ) Ins = Ins1 + Ins2 + Ins3 labs = [l.get_label() for l in Ins] ax1.legend(Ins, labs, loc="upper left") plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig("build/Plot_b_P" + str(P) + ".pdf")
'Druck': p, 'Weglange': w, 'verhaeltnis': verhaeltnis } ####### Frank-Hertz-Kurve abstand_frank_hertz, spannung_frank_hertz = np.genfromtxt( 'spannung_abstand_frankhertzkurve_188grad.txt', unpack=True) anzahl, abstaende_maxima = np.genfromtxt('abstaende_frankhertzkurve_188.txt', unpack=True) parmeter_frank_hertz = linfit(abstand_frank_hertz, spannung_frank_hertz, 1, 1, 1, 1, 'frank_hertz_kuvre') anregungsspannung = g(noms(parmeter_frank_hertz['Steigung']), abstaende_maxima, noms(parmeter_frank_hertz['Achsenabschnitt'])) anregungspannung_u = ufloat( np.mean(anregungsspannung), np.std(anregungsspannung, ddof=1) / np.sqrt(len(anregungsspannung))) anregungsenergie = anregungspannung_u #eV print('\n \n \n') print('Parameter Spannungs Fit Frank (m,b)', parmeter_frank_hertz['Steigung'], parmeter_frank_hertz['Achsenabschnitt']) print('Anregungsenergie (eV)', anregungsenergie) wellenlaenge = (h * speed_of_light) / (anregungsenergie * e) print('Wellenlänge', wellenlaenge) K_frank = 2 * anregungspannung_u - g( noms(parmeter_frank_hertz['Steigung']), 3.1,
def mean(values, axis=0): return unp.uarray((np.mean(noms(values), axis=axis), scipy.stats.sem(noms(values), axis=axis)))
#omega_x.SetParLimits(2, 5e-14 * 0.52, 4e-13) omega_x.SetParameter(0, 1e-10) omega_x.SetParameter(1, 0.00898) omega_x.SetParameter(2, (1060e-9)**2 / np.pi**2) omega_y.SetParameter(0, 1e-10) omega_y.SetParameter(1, 0.00898) omega_y.SetParameter(2, (1060e-9)**2 / np.pi**2) c1 = root.TCanvas("c1", "c1", 1980, 1080) c1.SetGrid() mg = root.TMultiGraph() #Create multigraph plot_xsigma = root.TGraphErrors(len(xsigma), array('f', noms(uheight)), array('f', noms(usigma_x)), array('f', stds(uheight)), array('f', stds(usigma_x))) plot_ysigma = root.TGraphErrors(len(xsigma), array('f', noms(uheight)), array('f', noms(usigma_y)), array('f', stds(uheight)), array('f', stds(usigma_y))) mg.GetXaxis().SetRangeUser(2., 10.) plot_xsigma.GetXaxis().SetMaxDigits(2) plot_xsigma.GetXaxis().SetLimits(0, 1) #Set xLimits plot_ysigma.GetXaxis().SetLimits(0, 1) #Set xLimits plot_xsigma.SetMarkerColor(1756)
uP_2 = unp.uarray(P_2, P_dim * [P_2_err]) #%% ## Plots der Temperaturverläufe # 16 t- Werte in Sekunden (0, 90, 180, ..., 1350) t = np.linspace(0, (T_dim - 1) * DELTA_T, num=T_dim) # "Kontinuierliche" Werte von -10 bis 2000 x = np.linspace(-10, 2000, num=1000) # Bearbeitung von T_1 #Berechnung der Fit-Parameter poptI_T1, pcovI_T1 = curve_fit(T_FitI, t, noms(uT_1), sigma=stds(uT_1)) poptII_T1, pcovII_T1 = curve_fit(T_FitII, t, noms(uT_1), sigma=stds(uT_1)) poptIII_T1, pcovIII_T1 = curve_fit(T_FitIII, t, noms(uT_1), sigma=stds(uT_1)) # Berechnung der Fit-Fehler errorI_T1 = np.sqrt(np.diag(pcovI_T1)) #errorII_T1 = np.sqrt(np.diag(pcovII_T1)) #errorIII_T1 = np.sqrt(np.diag(pcovIII_T1)) uA_1 = ufloat(poptI_T1[0], errorI_T1[0]) uB_1 = ufloat(poptI_T1[1], errorI_T1[1]) uC_1 = ufloat(poptI_T1[2], errorI_T1[2]) # Plot Einstellungen