def make_table(resultPath, classifer, splitFile, op, lk, tp): table.make_table(resultPath=resultPath, classifer=classifer, splitFile=splitFile, op=op, lk=lk, tp=tp)
def start(self): from table import make_table stbase.Strategy.start(self) stbase.println("Strategy : Sample Started..") cfgs = self.param_table params = cfgs.get("PARAMS") entries = [] if not cfgs.get("TEST_ARRAY"): entries = make_table(params) else: entries = cfgs.get("TEST_ARRAY" ) for idx, bar in enumerate(self.bar_list): bar.index = idx name_ov = 'runtest_overview_{}_{}.txt'.format(SYMBOL,INDEX) if os.path.exists(name_ov): os.remove(name_ov) # for pandas excel fields = OrderedDict(params=[],open_times=[], close_times=[], fee=[], profit=[],date_range=[],sample_num=[], sample_unit=[],init_funds=[],curr_funds=[],curr_margin=[] ) global STOP_WIN ,STOP_WIN_MIN ,N ,TIMEPERIOD,INIT_FUNDS ,LOT_PER_UNIT self.overview_report_ready() for p in entries: STOP_WIN = p['stop_win'] STOP_WIN_MIN = p['stop_win_min'] TIMEPERIOD = p['timeperiod'] N = p['n'] print '>>', STOP_WIN ,STOP_WIN_MIN ,N ,TIMEPERIOD # From Here self.reset() for bar in self.bar_list: self.onBar(bar) self.output_file = open(name_ov, 'a+') self.reportView(fields) # 净值处理 self.data_net_report() self.overview_report_datarecord() self.overview_report_write() df = pd.DataFrame(fields) df.to_excel("runtest_overview_{}_{}.xlsx".format(SYMBOL,INDEX))
def result(result_list): a_lst = [] for client in result_list: lst = [] lst.append(client["ip"]) lst.append(client["mac"]) lst.append(client["mac_vendor"]) a_lst.append(lst) labels = ["IP", "MAC Address", "MAC Vendor"] a = table.make_table(rows=a_lst, labels=labels, centered=True) print(a)
def main(args=None): # print('PHA debug in main') # parser = make_parser() # args=parser.parse_args(args) # # find the notebooks list # root_dir = context.curr_dir.parents[1] website_dir = root_dir / Path("website") notebook_dir = root_dir / Path("notebooks") print(f"found notebook_dir {notebook_dir}") json_path = website_dir / Path("notebooks.json") with open(json_path, "r") as json_file: notebook_order = json.load(json_file) print(f"notebook order: {notebook_order}") txt_out = website_dir / Path("index_notebooks.txt") rst_out = website_dir / Path("notebook_index.rst") # print(f'here are the output files: {txt_out},{rst_out}') # print(f'DEBUG: here is the noteobok order from find_notebooks.py: \n{pprint.pformat(notebook_order)}\n') web_notebooks_path = website_dir / Path("web_notebooks") web_pybooks_path = website_dir / Path("_build/python") os.makedirs(web_notebooks_path, exist_ok=True) # # first line of table # table_list = [["cocalc folder", "html", "python"]] namelist = [] file_list = [] git_url = "https://github.com/phaustin/eosc213_students/blob/master/python" for week, weeklist in notebook_order.items(): week_head = "**{}**".format(week) table_list.append([week_head, " ", " "]) for notebook in weeklist: py_name = f"{notebook}.py" nb_name = f"{notebook}.ipynb" try: nb_file = list(context.student_dir.glob(f"**/{nb_name}"))[0] except IndexError: print(f"error locating {context.student_dir} / {nb_name}") sys.exit(1) print(f"processing {nb_file} in folder {context.student_dir}") try: py_file = list(context.student_dir.glob(f"**/{py_name}"))[0] except IndexError: print(f"error locating {context.student_dir} / {py_name}") sys.exit(1) print(nb_file.is_file()) nb_path = str(nb_file.relative_to(context.student_dir)) shutil.copy(nb_file, web_notebooks_path) shutil.copy(py_file, web_pybooks_path) namelist.append(notebook) ipynb = r"{}_ipynb_" html = r"`{}_html`_" python = r"`{}_py`_" ipynb, html, python = [ item.format(notebook) for item in [ipynb, html, python] ] ipynb = nb_path table_list.append([ipynb, html, python]) file_list.append(nb_path) print(f"tablelist: {table_list}") # # # # write out the shortcuts # # with open(txt_out, "w") as notetxt: print(f"writing {str(txt_out.resolve())}") for name, filepath in zip(namelist, file_list): notetxt.write(f".. _{name}_ipynb: {filepath}\n") notetxt.write(f".. _{name}_html: web_notebooks/{name}.ipynb\n") notetxt.write(f".. _{name}_py: {git_url}/{name}.py\n") header = """ .. include:: index_notebooks.txt .. _notebooks: E213 notebooks in order of appearance ===================================== """ header = textwrap.dedent(header) # pdb.set_trace() with open(rst_out, "w") as noterst: print(f"writing {str(rst_out.resolve())}") noterst.write(header) noterst.write(make_table(table_list))
import matplotlib.pyplot as plt from scipy.optimize import curve_fit from uncertainties import ufloat from table import( make_table, make_SI, write) # Spannungen und Ströme einlesen spannung_orange, orange = np.genfromtxt('Daten1.txt', unpack=True) spannung, rot, grun, lila, blau, uv = np.genfromtxt('Daten2.txt', unpack=True) matrix=np.array([rot, grun, lila, blau, uv]) #werte in tabelle schreiben write('build/tabelle_alle_wellenlangen.tex', make_table([spannung, rot, grun, lila, blau, uv],[2,0,0,0,0,0])) write('build/tabelle_alle_wellenlangen_wurzel.tex', make_table([spannung, np.sqrt(rot), np.sqrt(grun), np.sqrt(lila), np.sqrt(blau), np.sqrt(uv)],[2,1,1,1,1,1])) write('build/tabelle_orange_wellenlange.tex', make_table([spannung_orange, orange],[2,0])) #pikoampere in ampere umrechnen matrix = matrix*10**-12 orange = orange*10**-12 #Werte mit positivem strom heraussuchen und plotten matrix_plus = np.ones((len(matrix[:,0]),len(matrix[0,:]))) #matrix_plus = np.ones((10,5))
# Bestimmung der Gitterkonstante # bekannte Wellenlängen der Helium Spektrallinien (hier muss die # Reihenfolge natürlich übereinstimmen mit derjenigen der Datei # WinkelHelium.txt): lambda_helium = np.array([438.8, 447.1, 471.3, 492.2, 501.6, 504.8, 587.6, 667.8, 706.5]) * 1e-9 # in m # sinus für den plot und den fit sin_phi_helium = np.array(np.sin(phi_helium)) # fit sin(phi) gegenüber lambda zur Bestimmung von g 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)
params = ucurve_fit(reg.reg_linear, abstand_skala1_a, f1_a) m1, b1 = params write('build/m1_a.tex', make_SI(m1*1e3, r'\per\centi\meter', 'e-3', figures=1)) # type in Anz. signifikanter Stellen write('build/b1_a.tex', make_SI(b1*1e3, r'', 'e-3', figures=1)) # Teil 2 f2_log_a = np.array([26800.1, 29500, 32800, 36400, 40100, 44300, 48700, 53500, 58800, 64200, 70200, 77500]) abstand_skala2_a = [0,2,4,6,8,10,12,14,16,18,20,22] f2_a = np.log(f2_log_a) params = ucurve_fit(reg.reg_linear, abstand_skala2_a, f2_a) m2, b2 = params write('build/m2_a.tex', make_SI(m2*1e3, r'\per\centi\meter', 'e-3',figures=1)) # type in Anz. signifikanter Stellen write('build/b2_a.tex', make_SI(b2*1e3, r'', 'e-3', figures=1)) write('build/Tabelle_a.tex', make_table([abstand_skala1_a, f1_log_a*1e-3, f1_a, abstand_skala2_a, f2_log_a*1e-3, f2_a], [0, 1, 2, 0, 1, 2])) # type in Nachkommastellen # FULLTABLE write('build/Tabelle_a_texformat.tex', make_full_table( 'Messdaten Aderlasskurven.', 'table:A1', 'Tabelle_a.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen ['$\\textrm{Abstand}_\\textrm{C} \\:/\\: \\si{\\cm}$', '$\\nu_\\textrm{C} \\:/\\: \\si{\\kilo\\hertz}$', '$\\log{\\abs{\\nu_\\textrm{C}}}$', '$\\textrm{Abstand}_\\textrm{C$_1$,C$_2$} \\:/\\: \\si{\\cm}$', '$\\nu_\\textrm{C$_1$,C$_2$} \\:/\\: \\si{\\kilo\\hertz}$', '$\\log{\\abs{\\nu_\\textrm{C$_1$,C$_2$}}}$'])) # Testplot für lin. fit
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 write('build/Tabelle_Geschwindigkeiten.tex', make_table([v_auf, v_auf ,v_0, U],[1, 1, 3, 0])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Geschwindigkeiten_texformat.tex', make_full_table( caption = 'Mittelwerte der Messdaten für jedes untersuchte Tröpfchen und zugehörige Spannung.', label = 'table:A2', source_table = 'build/Tabelle_Geschwindigkeiten.tex', stacking = [0,1], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [ r'$v_\textrm{auf} \:/\: \si{\milli\meter\per\second}$', r'$v_\textrm{ab} \:/\: \si{\milli\meter\per\second}$', r'$v_0\:/\: \si{\milli\meter\per\second}$', r'$U\:/\: \si{\volt}$'])) write('build/Tabelle_Kriterium.tex', make_table([2*v_0, v_ab-v_auf],[3,3])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Kriterium_texformat.tex', make_full_table( caption = 'Überprüfung der Bedinung.',
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
# vacuum velo of light c = 299792458 # metre per second # diffraction distance d = 201.4e-12 # metre #elementary charge e = 1.6e-19#coulomb #Rydbergonstante r = 13.6 #eV #sommerfeldsche Feinstrukturkonstante s_k = 7.29e-3 zwei_theta, impulsrate = np.genfromtxt('messdaten/1_Messung_werte.txt', unpack=True) write('build/Tabelle_messung_1.tex', make_table([zwei_theta,impulsrate],[1, 0])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_messung_1_texformat.tex', make_full_table( 'Messdaten Bragg Bedingung.', 'table:A2', 'build/Tabelle_messung_1.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r'$\theta \:/\: \si{\degree}$', r'$Zaehlrate$'])) theta, Z = np.loadtxt("messdaten/Bremsberg_werte.txt", unpack=True) theta = theta/2
print('eta_1:', eta_1) print('eta_2:', eta_2) ################################################################ ### etas und phi ausrechnen ################################################################ phi = 0.5 * (phi_1 - phi_2) phi_Mittel = ufloat(np.mean(phi), np.std(phi)/np.sqrt(len(phi))) # eta = 180 - (360 + eta_1 - eta_2) eta = 180 - (eta_1-eta_2) # mit den Werten von Sonja und Saskia print('eta:', eta) print('phi_Mittel:', phi_Mittel) write('build/Messwerte1.tex', make_table([phi_1, phi_2, phi],[1,1,1])) write('build/Winkel_Prisma.tex', make_SI(phi_Mittel,r'',figures=1)) write('build/Messwerte2.tex', make_table([wavelength*10**9, eta_1, eta_2, eta],[2,1,1,1])) ################################################################ phi_Mittel = 60 ################################################################ ### Brechzahl ################################################################ n = unp.sin( 0.5 * 2 * np.pi / 360 * (eta + phi_Mittel) ) / unp.sin( 0.5 * 2 * np.pi / 360 * phi_Mittel) print('Brechzahl:', n)
########## DIFFERENT STUFF ########## # R = const.physical_constants["molar gas constant"] # Array of value, unit, error ### VORARBEITEN #### h_zylinder, t_zylinder = np.genfromtxt('messdaten/a.txt', unpack=True) h_zylinder = h_zylinder*10**(-3) t_zylinder = t_zylinder*10**(-6) ##### a ##### v_zylinder = 2*h_zylinder/t_zylinder write('build/Tabelle_0.tex', make_table([h_zylinder*10**3, t_zylinder*10**6, v_zylinder],[2, 1, 2])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_0_texformat.tex', make_full_table( 'Bestimmung der Schallgeschwindigkeit mittels Impuls-Echo-Verfahren.', 'tab:0', 'build/Tabelle_0.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [r'$h_{\text{zylinder}} \:/\: 10^{-3} \si{\metre}$', r'$\increment t \:/\: 10^{-6} \si{\second} $', r'$c_\text{Acryl} \:/\:\si{\metre\per\second} $'])) c_arcyl_1 = ufloat(np.mean(v_zylinder), np.std(v_zylinder)) write('build/c_acryl_1.tex', make_SI(c_arcyl_1, r'\metre\per\second', figures=2)) # type in Anz. signifikanter Stellen params = ucurve_fit(reg_linear, 0.5*t_zylinder, h_zylinder) # linearer Fit a, b = params
saturation_current_4 = saturation_current(d.anode_4,1) saturation_current_5 = saturation_current(d.anode_5,1) saturation_current = [] saturation_current.append(saturation_current_1) saturation_current.append(saturation_current_2) saturation_current.append(saturation_current_3) saturation_current.append(saturation_current_4) saturation_current.append(saturation_current_5) saturation_tab = copy.deepcopy(saturation_current) d.make_it_SI2(saturation_tab,6) #write('../tex-data/saturation.tex', # make_table([[1,2,3,4,5],saturation_current], [0, 6])) write('../tex-data/saturation.tex', make_table([[1,2,3,4,5],saturation_tab], [0, 0])) print("Sättigungsstrom 1:",saturation_current_1) print("Sättigungsstrom 2:",saturation_current_2) print("Sättigungsstrom 3:",saturation_current_3) print("Sättigungsstrom 4:",saturation_current_4) print("Sättigungsstrom 5:",saturation_current_5) #calculationg the Langmuir-Schottkysche exponent - should be 1.5 def langmuh_Reg(V, a, b): return a*V + b def make_it_ln(array, k): """takes the logarithm"""
from table import( make_table, make_SI, write, make_composed_table) e1, e2, t1, t2 = np.genfromtxt('WerteA.txt', unpack=True) print(e1) # in SI-Einheiten umrechnen e1 = e1/100 e2=e2/100 t1=t1*10**-6 t2=t2*10**-6 #schallgeschwindigkeit in acryl c = 2730 s1 = c*t1/2 s2= c*t2/2 print(np.mean(s1-e1)) print(np.mean(s2-e2)) print(s1) print(s2[::-1]) write('build/tabelle_WerteA.txt', make_table([e1*100, s1*100, (s1-np.mean(s1-e1))*100, e2*100, s2*100, (s2-np.mean(s2-e2))*100], [3,3,3,3,3,3]))
make_table, make_full_table, make_composed_table, make_SI, write, ) ###################################################################################################################################################### ## Verdampfungswärme # Daten einlesen vorgegebene Daten p1, T1 = np.genfromtxt('Messdaten/Verdampfungskurve.txt', unpack=True) T1 += 273.1 # T in K p1 += 1 # Offset 1 bar p1 *= 1e5 # in Pa write('build/Tabelle_Verdampfungskurve.tex', make_table([T1, p1, 1e3/(T1), np.log(p1)], [1,1,3,2])) write('build/Tabelle_Verdampfungskurve_texformat.tex', make_full_table( 'Abgelesene und daraus abgeleitete Werte für die Berechnung der Verdampfungswärme.', 'table:A1', 'build/Tabelle_Verdampfungskurve.tex', [], [r'$T \:/\: \si{\kelvin}$', r'$p \:/\: \si{\bar}$', r'$\frac{1}{T} \:/\: 10^{-3}\si{\per\kelvin}$', r'$\ln{(p/\si{\pascal})}$'])) # Fit Verdampfungskurve params = ucurve_fit(reg.reg_linear, 1/T1, np.log(p1), p0=[-1, 1]) m1, b1 = params write('build/m1.tex', make_SI(m1, r'\kelvin', '', 1)) # 1 signifikante Stelle write('build/b1.tex', make_SI(b1, r'', '', 1)) # 1 signifikante Stelle
import scipy.constants as const import uncertainties.unumpy as unp from uncertainties import ufloat from uncertainties.unumpy import ( nominal_values as noms, std_devs as stds, ) from curve_fit import ucurve_fit from table import ( make_table, make_SI, write, ) p1, T1, T1_fl = np.genfromtxt('Messwerte/bis1000mBar.txt', unpack=True) write('build/MessdatenBis1Bar.tex', make_table([T1, p1, 1e3/(T1+273.1), np.log(p1*1e2)], [0,0,3,2])) # p1 in mbar, T in °C, 1/T in 10^-3 K^-1, ln(p/Pa) T1 += 273.1 # T in K p1 *= 1e2 # p in N/m^2 (Pa) # lineare Regression def f(x, m, b): return m * x + b # Druck als Funktion der Temperatur n=3 def g(x, d, c, b, a): return d*x**3+c*x**2+b*x+a # Druck als Funktion der Temperatur n=4 def h(x, e, d, c, b, a): return e*x**4+d*x**3+c*x**2+b*x+a # Verdampfungswärme als Funktion der Temperatur def L(konst_a, konst_R, T, d, c, b, a):
# STEP 3 read files FAILED_TO_READ_FILES = [p for p, f in FILE_PATH_STR_PAIRS if f is None] FILE_PATH_STR_PAIRS = [x for x in FILE_PATH_STR_PAIRS if not x[1] is None] NUMBER_OF_READ_FILES = len(FILE_PATH_STR_PAIRS) if NUMBER_OF_FILES > NUMBER_OF_READ_FILES: logger.log_failed_reads( NUMBER_OF_FILES, NUMBER_OF_READ_FILES, FAILED_TO_READ_FILES ) # STEP 4 remove failed to read files print(f"\nextracting data from {NUMBER_OF_READ_FILES} files...") DATA_FRAME, ERRORS = make_table( proc.SELECTORS, FILE_PATH_STR_PAIRS ) proc.WRITER(EXCEL_PATH, DATA_FRAME) # STEP 5 generate excel file if not ERRORS.empty: logger.log_errors(ERRORS) logger.log_success(NUMBER_OF_READ_FILES, NUMBER_OF_FILES, EXCEL_PATH) # STEP 6 print results
write('build/Geschwindigkeitsabweichung.tex', make_SI((c_acryl_1/c_acryl)*1e2, r'\percent', figures=1)) silikon_konst = 3#ms write('build/konst.tex', make_SI(silikon_konst, r'\micro\second', figures=1)) silikon_konst *= 1e-6 #sekunden Abstände_A = np.genfromtxt('messdaten/Abstände.txt', unpack=True) # in centimeter Abstände_B = Höhe-Abstände_A Abstand = np.genfromtxt('messdaten/Abstände.txt', unpack=True) Abstand_B = Höhe - Abstand # # y[n - 1::n] print('Hallo') print(Num[0:5]) print(Num[6:10]) write('build/Tabelle_Abstaende.tex', make_table([Num,Abstand],[0,2])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Abstaende_texformat.tex', make_full_table( 'Gemessene Tiefe der Bohrungen aus Sicht der "A-Seite".', 'table:A5', 'build/Tabelle_Abstaende.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r'$\text{Num.} $', r'$\text{Tiefe} \:/\: \si{\centi\meter}$'])) #### A-Scan #### Ich schätze einen Ablesefehler von 0.1 Fehler_A = 0.1*1e-6 #in sekunden Werte_A_A, Werte_A_B = np.genfromtxt('messdaten/aufgabenteil_a.txt', unpack=True) t_a_a = unp.uarray(Werte_A_A, Fehler_A)
Nu=460 t_0=900 #in s N_Offset_Indium = (Nu/t_0)*220 write('build/Fehler_Indium.tex', make_SI(N_Offset_Indium, r'', figures=1)) N_Offset_Silber = (Nu/t_0)*9 #Import Data #Indium = Ind #Silber = Si Ind_nom, t = np.genfromtxt('messdaten/Indium.txt', unpack=True) Ind_nom = Ind_nom - N_Offset_Indium Ind = unp.uarray(Ind_nom, np.sqrt(Ind_nom)) # Ind = unp.uarray(Ind_nom, N_Offset_Indium) write('build/Tabelle_Indium.tex', make_table([Ind,t],[1, 0])) write('build/Tabelle_Indium_texformat.tex', make_full_table( caption = 'Messdaten von Indium unter Berücksichtigung des Nulleffekts.', label = 'table:Indium', source_table = 'build/Tabelle_Indium.tex', stacking = [0], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [ r'$N_\textrm{\Delta t}$', r'$t \:/\: \si{\second}$'])) # default = '-' Si_nom, t_Si = np.genfromtxt('messdaten/Silber.txt', unpack=True) Si_nom = Si_nom - N_Offset_Silber
D_mess_o = D_o D_mess_u = D_o D_mess_o = c*t_o/2 D_mess_u = c*t_u/2 D_loch = hoehe_mess - (D_mess_o + D_mess_u) D_mess_o = D_mess_o*10**(2) D_mess_u = D_mess_u*10**(2) D_o = D_o*10**2 D_loch = D_loch*10**3 List = [1,2,3,4,5,6,7,8,9,10,11] write('build/Tabelle_a.tex', make_table([List, D_o, D_mess_o, D_mess_u, D_loch],[0,2,2,2,2])) #cm, cm ,cm, mm write('build/Tabelle_a_texformat.tex', make_full_table( 'Messdaten Tiefenmessungen.', 'table:1', 'build/Tabelle_a.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r'$\text{Stelle}$', r'$D_{\text{oben}} \:/\: \si{\centi\metre}$', r'$D_{\text{oben,gem}} \:/\: \si{\centi\metre}$', r'$D_{\text{unten,gem}} \:/\: \si{\centi\metre}$', r'$D_{\text{loch,gem}} \:/\: \si{\milli\metre}$'])) D_o_rel_a = abs(D_mess_o-D_o)/D_o * 100 D_o_rel_a = np.mean(D_o_rel_a)
from ErrorCalculation import ( MeanError, rmse, ) #a) Wheatstonebrücke #Widerstand Wert 14, 10 Wert_a, R_2, c = np.genfromtxt('Messergebnisse/a.txt', unpack=True) R_2er = R_2*0.002 R_3 = c R_4 = 1000-c R_34 = R_3 / R_4 R_34er = R_34*0.005 R2 = unp.uarray(R_2, R_2er) R34 = unp.uarray(R_34, R_34er) write('build/wheat1tabelle.tex', make_table([Wert_a, R2, R34], [0,1,1 , 1, 1])) Rx = R2*R34 Rx_mean_Wert14=np.mean(Rx[0:3]) Rx_mean_Wert10=np.mean(Rx[3:6]) Rx_mean_Wert14_err = MeanError(noms(Rx[0:3])) Rx_mean_Wert10_err = MeanError(noms(Rx[3:6])) # Building Arrays from this... Werte_a = np.array([Wert_a[0], Wert_a[3]]) Rx_mean = np.array([Rx_mean_Wert14, Rx_mean_Wert10]) # Mittelwert und syst. Fehler Rx_mean_err = np.array([Rx_mean_Wert14_err, Rx_mean_Wert10_err]) # stat. Fehler write('build/Tabelle_err_a.tex', make_table([Werte_a, Rx_mean, Rx_mean_err],[0, 1, 0])) write('build/Tabelle_a.tex', make_table([Wert_a, R2, R34, Rx], [0, 1, 1, 1]))
slit_count = 0 for slit in data.slits: slit_count += 1 count = len(slit.currents) midpoint = (slit.midpoint_index + 1) spacing = slit.spacing angles_left = np.linspace(-(midpoint) * spacing, -spacing, midpoint) angles_right = np.linspace(0, (count - midpoint) * spacing, count - midpoint) slit.angles = np.arctan(np.append(angles_left, angles_right) / data.screen_distance) slit.currents_sigma = hel.estimate_sigmas_only(slit.currents, data.analoge_abberation) np.savetxt("data/single_slit" + str(slit_count) + ".data", np.transpose([slit.angles, slit.currents]), header='Angle, Current') make_table([np.array(slit.angles) * 1e3, np.array(slit.currents) * 1e6, np.array(slit.currents_sigma) * 1e6], "../table/single_slit" + str(slit_count) + ".tex", figures=[2, 2, 3]) if __name__ == "__main__": slit_count = 0 runSingleSlits = False if runSingleSlits: for slit in data.single_slits: slit_count += 1 fit_params, quality = mulitopt([slit.angles, slit.currents, single_slit_fit], 1e-6, 9e-4, 100, [10, 1e-10], slit.currents_sigma) info("Fit Quality %s", quality) info("Slit Size %s", fit_params[0]) phi_offset = fit_params[2]
from utility import( constant ) ################################################ Finish importing custom libraries ################################################# ########################### a) ############################ Z, I = np.genfromtxt('messdaten/a.txt', unpack=True) # I in µA I = I*1e-6 # in A U = np.array(range(320, 710, 10)) delta_t = 10 # fix for a) Z_err = np.sqrt(Z) # poisson verteilt Z_unc = unp.uarray(Z, Z_err) # mit Fehlern versehen N = Z_unc / delta_t # Zählrate delta_Q = I/N/constant('elementary charge')*1e-10 # in 10^10 e write('build/Tabelle_a.tex', make_table([U, Z_unc, N, I*1e6, delta_Q],[0, 1, 1, 1, 1])) write('build/Tabelle_a_texformat.tex', make_full_table( caption = 'Messdaten für die Charakteristik des Zählrohrs.', label = 'table:a', source_table = 'build/Tabelle_a.tex', stacking = [1,2,4], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [r'$U \:/\: \si{\volt}$', r'$Z$', r'$N \:/\: \si{\per\second}$', r'$I \:/\: 10^{10}\si{\micro\ampere}$', r'$\Delta Q \:/\: \si{\elementarycharge}$'])) ##### Fit #### no_of_first_ignored_values = 3 no_of_last_ignored_values = 5
# Tabelle für Messdaten Tiefe, Delta_f_45, Intensity_45 = np.genfromtxt("messdaten/stroemungsprofil45.txt", unpack=True) Tiefe, Delta_f_70, Intensity_70 = np.genfromtxt("messdaten/stroemungsprofil70.txt", unpack=True) error = 0.07 Delta_f_45_error = Delta_f_45 * error Delta_f_45 = unp.uarray(Delta_f_45, Delta_f_45_error) Delta_f_70_error = Delta_f_70 * error Delta_f_70 = unp.uarray(Delta_f_70, Delta_f_70_error) Intensity_45_error = Intensity_45 * error Intensity_45 = unp.uarray(Intensity_45, Intensity_45_error) Intensity_70_error = Intensity_70 * error Intensity_70 = unp.uarray(Intensity_70, Intensity_70_error) write( "build/Tabelle_messdaten.tex", make_table([Tiefe, Delta_f_45, Intensity_45, Delta_f_70, Intensity_70], [0, 1, 1, 1, 1]), ) write( "build/Tabelle_messdaten_texformat.tex", make_full_table( "Messdaten zum Strömungsprofil.", "table:messdaten_b", "build/Tabelle_messdaten.tex", [1, 2, 3, 4], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r"$\text{Laufzeit} \:/\: \si{\micro\second}$", r"$\Delta f_{45\si{\percent}} \:/\: \si{\hertz}$", r"$I_{45\si{\percent}} \:/\: \si{\kilo\square\volt\per\second}$", r"$\Delta f_{70\si{\percent}} \:/\: \si{\hertz}$", r"$I_{70\si{\percent}} \:/\: \si{\kilo\square\volt\per\second}$",
def f_dispersion_kHz(t): return c.f_dispersion(d.L, d.C1, t) * 1e-3 phase = [] for i in range(len(d.dispersion.phase)): phase.append((i + 1) * np.pi) # Jede Lissajou-Figur liegt um pi von der nächsten entfernt phase[-1] /= d.dispersion.glieder_anzahl plot.plot(phase, d.dispersion.frequenz * 1e-3, f_dispersion_kHz, r"Phasenverschiebung in Radian", r"Anregungsfrequenz in kHz", "dispersion.pdf") make_table(( range(1, len(d.dispersion.phase) + 1), d.dispersion.frequenz * 1e-3, phase, ), "../table/dispersion.tex", figures=[1, 1, 2]) print("--- Plot Frequenz gegen Phasengeschwindigkeit ---") def phase_theorie(f): return c.phasengeschwindigkeit_theorie(d.C1, d.L, f * 1e3) x = d.dispersion.frequenz # d.eigenfrequenzen_homogen werden nicht benötigt! Sie sind identisch mit ~ y = c.phasengeschwindigkeit(x, phase) plot.plot(x * 1e-3, y, phase_theorie, r"Anregungsfrequenz in kHz", "Phasengeschwindigkeit in Gliedern/s", "phasengesch.pdf")
# bekannte Wellenlängen der Helium Spektrallinien (hier muss die # Reihenfolge natürlich übereinstimmen mit derjenigen der Datei # WinkelHelium.txt): lambda_helium = np.array([438.8, 447.1, 471.3, 492.2, 501.6, 504.8, 587.6, 667.8, 706.5]) * 1e-9 # in m # sinus für den plot und den fit sin_phi_helium = np.array(np.sin(phi_helium)) # fit sin(phi) gegenüber lambda zur Bestimmung von g 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)$')
T_ohneB_roh = np.genfromtxt('Messdaten/OhneB.txt', unpack=True) T_ohneB = ufloat(np.mean(T_ohneB_roh), np.std(T_ohneB_roh)) write('build/T_ohneB.tex', make_SI(T_ohneB, r'\second', figures=1)) T_mitB_roh = np.genfromtxt('Messdaten/MitB.txt', unpack=True) T_mitB = ufloat(np.mean(T_mitB_roh), np.std(T_mitB_roh)) write('build/T_mitB.tex', make_SI(T_mitB, r'\second', figures=1)) T_10 = np.genfromtxt('Messdaten/I10.txt', unpack=True) T_08 = np.genfromtxt('Messdaten/I08.txt', unpack=True) T_06 = np.genfromtxt('Messdaten/I06.txt', unpack=True) T_04 = np.genfromtxt('Messdaten/I04.txt', unpack=True) T_02 = np.genfromtxt('Messdaten/I02.txt', unpack=True) I=np.array([1,0.8,0.6,0.4,0.2]) write('build/Tabelle_Strom.tex', make_table([T_10,T_08,T_06,T_04,T_02],[3, 3, 3, 3, 3])) # FULLTABLE write('build/MagnetfeldPerioden_texformat.tex', make_full_table( 'Periodendauern mit eingeschalteter Helmholtzspule.', 'table:MagnetfeldPerioden', 'build/Tabelle_Strom.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen [r'$T_{1,0\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,4\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,6\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,8\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,2\si{\ampere}} \:/\: \si{\second}$'])) write('build/aaa.tex', make_table([T_ohneB_roh, T_mitB_roh],[3, 3])) # FULLTABLE
print ('Parabel') print (a_parabel) a_parabel *= 0.5967 # b) n = [1,2,3,4,5,6,7,8,9] n_ungerade = [1,3,5,7,9,11,13,15,17] U_Dreieck, Skala_Dreieck = np.genfromtxt('Messdaten/Dreieckspannung.txt', unpack=True) U_Dreieck_Fehler = 0.1 * Skala_Dreieck U_Dreieck *= Skala_Dreieck U_Dreieck_ges = unp.uarray(U_Dreieck, U_Dreieck_Fehler) U_Dreieck_normiert = U_Dreieck_ges / U_Dreieck_ges[0] RelFehler_Dreieck = np.abs(U_Dreieck_normiert - a_Dreieck) / a_Dreieck * 100 write('build/Tabelle_Dreieck_1.tex', '1 & 2.8 & 0.1 & 1 & 0 & 1 & 0 & 0 \\\\') write('build/Tabelle_Dreieck_2.tex', make_table([n_ungerade[1:],U_Dreieck_ges[1:],U_Dreieck_normiert[1:],a_Dreieck[1:], RelFehler_Dreieck[1:]],[0, 1, 1, 3, 1])) write('build/Tabelle_Dreieck.tex', make_composed_table(['build/Tabelle_Dreieck_1.tex','build/Tabelle_Dreieck_2.tex'])) ## FULLTABLE write('build/FK_Dreieck_texformat.tex', make_full_table( 'Messdaten, Theoriewerte und relativer Messfehler $f$ der normierten Fourierkoeffizienten: Dreieckspannung.', 'table:FK_Dreieck', 'build/Tabelle_Dreieck.tex', [1,2,4], ['$k$', r'$U_{k,\text{mess}} \:/\: \si{\volt}$', r'$\frac{U_{k,\text{mess}}}{U_{1,\text{mess}}}$', r'$\Abs{\frac{U_{k,\text{theo}}}{U_{1,\text{theo}}}}$', r'$f$ \:/\: \si{\percent}'])) U_Rechteck, Skala_Rechteck = np.genfromtxt('Messdaten/Rechteckspannung.txt', unpack=True)
#write('../tex-data/v.tex', # make_table([[drops[i][0] for i in range(len(drops))], [drops[i][1] for i #in range(len(drops))], [drops[i][2] for i in range(len(drops))], #[drops[i][3] for i in range(len(drops))]], [0, 1, 1, 1])) fuck1 = [] fuck2 = [] fuck3 = [] fuck4 = [] for i in range(len(drops)): fuck1.append(drops[i][0]) fuck2.append(drops[i][1]*10**(5)) fuck3.append(drops[i][2]*10**(5)) fuck4.append(drops[i][3]*10**(5)) print(fuck3) write('../tex-data/v.tex', make_table([fuck1,fuck2,fuck3,fuck4], [0, 2, 2, 2])) #print(drops) #for i in range(len(drops)): # diff = drops[i][2]-drops[i][3] # print(diff, i) # if drops[i][1] != 0: # c = 2*drops[i][1] / diff # print("Difference:" ,c ,"Stelle:", i) # #for i in range(len(drops2)): # diff = drops2[i][2]-drops2[i][3] # print(diff, i) # if drops2[i][1] != 0: # c2 = 2*drops2[i][1] / diff # print("Difference:" ,c2 ,"Stelle:", i)
from scipy.optimize import curve_fit from uncertainties import ufloat from scipy.constants import e from table import ( make_table, make_full_table, make_SI, write,) U, c = np.genfromtxt('Messung1.txt', unpack = True) t = 10 #Messzeit 10 sekunden Z = c / t #Zählrate in counts/second Z_fehler = np.sqrt(c)/t write('build/tabelle_charakteristik.txt', make_table([U[:15], Z[:15], Z_fehler[:15], U[15:], Z[15:], Z_fehler[15:]], [2,2,2,2,2,2])) plt.plot(U, Z, 'ko', label='Messwerte') plt.errorbar(U, Z, xerr=1, yerr=Z_fehler, fmt='r.', label = r'Statistischer Fehler') plt.legend(loc='best') plt.xlabel(r'Spannung $U \ /\ \mathrm{V}$') plt.ylabel(r'Zählrate $Z \ /\ {\mathrm{Counts}}/{\mathrm{s}}$') plt.xlim(0,750) plt.savefig('build/charakteristik_gesamt.png') plt.show() def linear(x, m, b): return m*x+b
) plt.xlabel('Effektiver Abstand zwischen Detektor und Strahler x in cm') plt.ylabel('$10^3$ Pulse pro 120s') plt.ylim(30000,120000) plt.xlim(0,2.5) plt.legend(loc='lower left') # 2 = upper left plt.savefig('build/pulse1.png') plt.show() write('build/reichweite1.txt', make_SI(reichweite1, r'\centi\meter', figures=2)) write('build/m1.txt', make_SI(m1, r'\per\centi\meter', figures=1)) write('build/b1.txt', make_SI(b1, r'', figures=1)) write('build/tabelle_messung1.txt', make_table([p1, puls1, x1], [0,0,2])) ########gleiches für messung2 parameters2, popt2 = curve_fit(linear, x2[12:], puls2[12:]) m2 = ufloat(parameters2[0], np.sqrt(popt2[0,0])) b2 = ufloat(parameters2[1], np.sqrt(popt2[1,1])) #mittelere reichweite bestimmen (lineare gleichung auflösen) reichweite2 = (max(puls2)/2 - b2)/m2 print(reichweite2) x = np.linspace(0,3) plt.gca().yaxis.set_major_formatter(mpl.ticker.FuncFormatter(lambda x,_:x*10**(-3)))
plt.savefig('build/plot_ds.pdf') ####################### WRITING RESULT TABLES ####################### slits = ['klein', 'mittel', 'groß', 'doppel'] b = np.array([b_k, b_m, b_g, b_ds]) # in m b_hst = np.array([b_k_hst, b_m_hst, b_g_hst, b_ds_hst]) # in m b_err = np.abs(((b-b_hst) / b_hst)) # relative error A0 = np.array([A0_k, A0_m, A0_g, A0_ds]) # in A/m s_err = np.abs(np.array([(s_ds - s_ds_hst) / s_ds_hst])) # relative error s_mic = np.array([s_ds_mic]) s = np.array([s_ds]) s_hst = np.array([s_ds_hst]) write('build/Tabelle_results.tex', make_table([slits, zeta_0*1e3, A0, b_microscope*1e3, b*1e3, b_hst*1e3, b_err*1e2], [0, 2, 1, 2, 1, 2, 1])) write('build/Tabelle_results_texformat.tex', make_full_table( caption = r'Herstellerangaben, Mikroskopmessungen, Firparameter und der Fehler zwischen Fit und Herstellerangabe für die Spaltbreite $b$.', label = 'table:A1', source_table = 'build/Tabelle_results.tex', stacking = [2,4,6], units = [ 'Spalt', r'$\zeta_0 \:/\: \si{\milli\meter}$', r'$A_0 \:/\: \si{\ampere\per\meter}$', r'$b_\text{mic} \:/\: \si{\milli\meter}$', r'$b_\text{mess} \:/\: \si{\milli\meter}$', r'$b_\text{hst} \:/\: \si{\milli\meter}$', r'$|\varepsilon_b| \:/\: \si{\percent}$'])) write('build/Tabelle_results_s.tex', make_table([s_mic*1e3, s*1e3, s_hst*1e3, s_err*1e2], [2, 1, 2, 1]))
plt.xlabel('$t / s$') plt.ylabel('$N / 10s$ ') plt.yscale('log') plt.xlim([0,430]) plt.savefig('build/SilberAddiert.png') plt.show() write('build/Brom.tex', make_SI(ufloat(paramsBrom[0],np.sqrt(poptBrom[0,0])), r'\per\second', figures=1)) write('build/SilberKurz.tex', make_SI(ufloat(paramSK[0],np.sqrt(poptSK[0,0])), r'\per\second', figures=1)) write('build/SilberLang.tex', make_SI(ufloat(paramSL[0],np.sqrt(poptSL[0,0])), r'\per\second', figures=1)) write('build/BromB.tex', make_SI(ufloat(paramsBrom[1],np.sqrt(poptBrom[1,1])), r'', figures=1)) write('build/SilberKurzB.tex', make_SI(ufloat(paramSK[1],np.sqrt(poptSK[1,1])), r'', figures=1)) write('build/SilberLangB.tex', make_SI(ufloat(paramSL[1],np.sqrt(poptSL[1,1])), r'', figures=1)) Silber = unp.uarray(np.zeros(len(SilberAnf)), np.zeros(len(SilberAnf))) Brom = unp.uarray(np.zeros(len(BromAnf)), np.zeros(len(BromAnf))) for i in range(0, len(SilberAnf)): Silber[i] = ufloat(SilberAnf[i], np.sqrt(SilberAnf[i])) for i in range(0, len(BromAnf)): Brom[i] = ufloat(BromAnf[i], np.sqrt(BromAnf[i])) write('build/Werte.tex', make_table([Silber,Brom],[1,1]))
n=Nreps, processes=nproc)) summary_table_content.update({"solve": elapsed_time_solve}) if args.serial or run_all: elapsed_time = execute_n_times(solve_serial, solver_args, n=Nreps) summary_table_content.update({"serial": elapsed_time}) if args.map_serial or run_all: solver_args_map_serial = solver_args + [True] elapsed_time_map_serial = execute_n_times(solve_w_pool, solver_args_map_serial, n=Nreps) summary_table_content.update({"map-serial": elapsed_time_map_serial}) table = make_table(summary_table_content, nproc_range) if args.serial or run_all: with open("scaling_serial.txt", "w") as f: f.write(" ".join((f"{numvar:.3f}" for numvar in elapsed_time))) if args.map_serial or run_all: with open("scaling_map_serial.txt", "w") as f: f.write(" ".join( (f"{numvar:.3f}" for numvar in elapsed_time_map_serial))) if args.sharedarray or run_all: with open("scaling_sharedarray.txt", "w") as f: np.savetxt(f, np.array(elapsed_time_sharedarray), fmt="%.3f",
print(m_K) x = [] while i < np.size(m_K): x.append(S(c_W, m_w[i], c_g_m_g, T_M[i], T_W[i], m_K[i], T_K[i])) # np.append(x, S(c_W, m_w[i], c_g_m_g, T_M[i], T_W[i], m_K[i], T_K[i])) print(m_K[i], m_w[i], T_K[i], T_W[i], T_M[i], c_W, c_g_m_g) print(x) # write('build/Waermekapazitaeten_Blei['+str(i)+'].txt',str(x)) i += 1 print(np.std(x)) print(np.mean(x)) print(x) print(x[0]) c_k = ufloat(np.mean(x), np.std(x)) write("build/Waermekapazitaeten_Blei_gemittelt.tex", make_SI(c_k * 1e3, r"\joule\per\kelvin\per\kilogram")) write("build/blei_tabelle.tex", make_table([m_K, m_w, T_K, T_W, T_M], [0, 0, 1, 1, 1])) write("build/Waermekapazitaeten_Blei.tex", str(x[0]) + "&" + str(x[1]) + "&" + str(x[2])) write("build/Waermekapazitaeten_Blei.txt", str(x[0]) + " " + str(x[1]) + " " + str(x[2])) # aluminium m_K, m_w, T_K, T_W, T_M = np.genfromtxt("Messdaten/alu_messung.txt", unpack=True) c_W = np.genfromtxt("Messdaten/spezifischen_Waermekapazitaet.txt", unpack=True) c_g_m_g = np.genfromtxt("Messdaten/Waermekapazitaet.txt", unpack=True) print(m_K, m_w, T_K, T_W, T_M, c_W, c_g_m_g) x = S(c_W, m_w, c_g_m_g, T_M, T_W, m_K, T_K) c_k = x print(x) print(c_k) # write('build/Waermekapazitaeten_Alu.tex', make_SI(c_k)*1e3, r'\joule\per\kelvin\per\gram' )) write("build/Waermekapazitaeten_Alu.tex", str(c_k * 1e3))
# b) R_ap_exp = 3.3 print('Aufgabenteil b') print(L) print(C) R_ap = 2*unp.sqrt(L/C) R_ap *= 1e-3 # in kilo ohm print('R_ap') print(R_ap) L *=1e3 C *=1e9 div = R_ap - R_ap_exp write('build/Tabelle_aufgabenteil_b_gegeben.tex', make_table([ L, C, R_1],[1,1,1])) write('build/R_ap_exp.tex', make_SI(R_ap_exp, r'\kilo\ohm', figures=2)) write('build/R_ap.tex', make_SI(R_ap[0], r'\kilo\ohm', figures=1)) write('build/R_div.tex', make_SI((R_ap[0]-R_ap_exp), r'\kilo\ohm', figures=1)) ############c) fre, fre_err, abst, abst_err, U_c, U_c_err, U_er, U_er_err = np.genfromtxt('Messdaten/d.txt', unpack=True) fre_ges = unp.uarray(fre, fre_err) abst_ges = unp.uarray(abst, abst_err) U_c_ges = unp.uarray(U_c, U_c_err) U_er_ges = unp.uarray(U_er, U_er_err) write('build/Tabelle_aufgabenteil_c_Messdaten.tex', make_table([ fre_ges, abst_ges, U_c_ges, U_er_ges],[1,1,1,1]))
def main(): print_options() choice = get_input() # global variables start_year = 0 end_year = 0 # recursively process all e statements if choice == '1': statement_pattern = '\d+X+\d+-20\d{2}-\d{2}-\d{2}-20\d{2}-\d{2}-\d{2}.pdf$' statement_paths = Path('.').rglob('*.pdf') statements = [] # rename statements for path in statement_paths: if search(statement_pattern, str(path.name)): rename_file(path) statements.append(path) if len(statements) < 1: print('could not find any e statements...') os.system("pause") exit(0) start_year = int(statements[0].name.split('-')[1]) end_year = int(statements[len(statements) - 1].name.split('-')[1]) years = [] for i in range(start_year, end_year): years.append(i) data = prepare_data_json(start_year, end_year) # open statements and write to csv file csv_file = 'all-transactions.csv' csv_header = 'id, account , date, description, category, amount\n' f = open(csv_file, 'w') f.write(csv_header) for statement in progressBar(statements, prefix='Progress:', suffix='Complete', length=50): if len(statement.name) == 38: get_debit_data(statement, f, data) if len(statement.name) == 42: get_credit_data(statement, f, data) f.close() # give transactions an id add_transaction_id() # round amounts to two decimal places for i in data['category']: for j in data['category'][i]: data['category'][i][j] = round(data['category'][i][j], 2) for i in data['month']: for j in data['month'][i]: data['month'][i][j] = round(data['month'][i][j], 2) # process all-transactions.csv elif choice == '2': if not os.path.isfile('all-transactions.csv'): print('did not find all-transactions.csv') os.system("pause") exit(0) with open("all-transactions.csv", 'r') as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') rows = list(csv_reader) start_year = int(rows[1][2].split('-')[0]) end_year = int(rows[len(rows) - 1][2].split('-')[0]) data = prepare_data_json(start_year, end_year) line_count = 0 year = 0 month = '' amount = 0 for row in progressBar(rows, prefix='Progress:', suffix='Complete', length=50): if line_count == 0: line_count += 1 else: year = row[2].split('-')[0] month = get_month_name(row[2].split('-')[1]) amount = float(row[5]) data['category'][row[4]][int(year)] = amount data['month'][month][int(year)] = amount line_count += 1 # save data to json file save_data_json(data) # prepare data.js variables for visualization make_data_js(start_year, end_year) # convert all-transactions.csv to html table make_table()