def pltmitres(x, y, ex, ey, xl, yl, xeinheit, yeinheit, titel): """ Zum Erstellen eines Plots mit dazugehörigem Residumplot Parameter: x, y, ex, ey - Daten mit Fehler xl, yl : Titel der Achsen xeinheit, yeinheit : Einheit der Werte als String titel : titel des Plots Verwendung: x = np.arange(0.1,1,0.1) y = np.sin(x) ex = np.ones(len(x))*0.5 ey = np.ones(len(y))*0.2 pltmitres(x,y, ex, ey, "x", "y", "m/s", "s", "titel") plt.show() """ x = np.array(x) - np.average(x) y = np.array(y) - np.average(y) ex = np.array(ex) ey = np.array(ey) a, ea, b, eb, chiq, corr = anal.lineare_regression_xy(x, y, ex, ey) gs1 = GridSpec(3, 5) plt.subplot(gs1[:-1, :-1]) plt.title(titel) plt.errorbar(x, y, ey, ex, marker="x", linestyle="None", capsize=5) l = max(x) - min(x) x2 = np.arange(min(x) - l * 0.1, max(x) + l * 0.1, l / 1000) y2 = a * x2 + b plt.plot(x2, y2, color="orange") plt.ylabel(yl + " [{}]".format(xeinheit)) plt.ylim(top=7) print(ea) plt.legend( title= "Lineare Regression\n{} = ({:.5f} ± {:.5f}){}/{} $\cdot$ {}+({:.2f}±{:.2f}){}\n$\chi^2 /NDF={:.2f}$" .format(yl, a, ea, xeinheit, yeinheit, xl, b, eb, xeinheit, chiq / (len(x) - 2)), loc=1) plt.subplot(gs1[2, :-1]) plt.errorbar(x, y - a * x - b, np.sqrt(ex**2 * a**2 + ey**2), marker="x", linestyle="None", capsize=5) plt.axhline(0, color="orange") plt.xlabel(xl + " [{}]".format(yeinheit)) plt.tight_layout() return a, ea, b, eb, chiq
def test_lineare_regression_xy(): sigmax = 0.5 sigmay = 1.0 xmin = -20. xmax = 20. # wuerfele Daten x = np.arange(xmin, xmax) xdata = np.random.normal(x, sigmax) ydata = np.random.normal(3. + 0.5 * x, sigmay) ex = 0. * x + sigmax ey = 0. * x + sigmay # Aufruf der linearen Regression a,ea,b,eb,chiq,corr = \ analyse.lineare_regression_xy(xdata,ydata,ex,ey) print('Ergebnis: a=%f+-%f, b=%f+-%f, chi2=%f, corr=%f' % (a, ea, b, eb, chiq, corr)) figure() subplot(2, 1, 1) title('Lineare Regression') errorbar(xdata, ydata, xerr=ex, yerr=ey, fmt='o', color='blue') plot(x, a * x + b, '-') xlim(xmin - 1., xmax + 1.) xlabel('x') ylabel('y') grid() subplot(2, 1, 2) title('Residuenplot') errorbar(xdata, ydata - (a * xdata + b), xerr=ex, yerr=ey, fmt='o', color='blue') plot(x, 0. * x) # Linie bei Null xlim(xmin - 1., xmax + 1.) ylim(-5, 5) xlabel('x') ylabel('y-(ax+b)') show()
ephi0 = 1 / np.sqrt(12) * np.pi / 180 * np.ones(len(phi0)) # in radiant eU0 = 0.0005 * np.ones( len(U0)) # 0.6/4096/np.sqrt(12)*np.ones(len(U0)) #0.001 print('angenommenen Unsicherheiten: eU={}, ephi={}Grad'.format( eU0[0], ephi0[0] * 180 / np.pi)) print( 'Fehler auf U diesmal kleiner, weil Empfaenger und Sender recht dicht beieinander standen, fest installiert waren und dadurch das Rauschen einen geringeren Einfluss hat.' ) elogI0 = np.sqrt(((2 / (a_kalib)**2) * np.log(U0 - Umin) * ea_kalib)**2 + (2 * eU0 / (a_kalib * (U0 - Umin)))**2) elogcosphi0 = np.absolute(np.sin(phi0) / np.cos(phi0)) * ephi0 print('berechnete Fehler: elogI={}, elogcosphi={}'.format(elogI0, elogcosphi0)) x, ex, b, eb, chiq, corr = analyse.lineare_regression_xy( logcosphi0, logI0, elogcosphi0, elogI0) print('Ergebnis: x=%f+-%f, b=%f+-%f, chi2=%f, corr=%f' % (x, ex, b, eb, chiq, corr)) figure() #title('Lin. Reg. zum Gesetz von Malus') errorbar(logcosphi0, logI0, xerr=elogcosphi0, yerr=elogI0, linestyle='none', marker='o', markersize=2, elinewidth=1, zorder=1)
m = np.arange(0, len(s) * 10, 10) #13 delta, edelta_sys, edelta = stodelta(s, np.ones(len(s)) * e_s) em = np.ones(len(delta)) * e_m ax1, ax2, a, ea, b, eb, chiq, corr = bib.pltmitres(m, delta, edelta, ex=em, xl="m", yl="mm", regData=True, title="grun" + str(i)) print("lambda", i, "=", 2 * a * 10**6) print("e_lambda", i, "=", 2 * ea * 10**6) #Verschiebemethode ap, eap, bp, ebp, chiq, corr = anal.lineare_regression_xy( m + e_m, delta + edelta_sys, em, edelta) am, eam, bm, ebm, chiq, corr = anal.lineare_regression_xy( m - e_m, delta - edelta_sys, em, edelta) e_l_sys = np.max((np.abs(a - ap), np.abs(a - am))) * 2 * 10**6 print("e_lambda_sys", i, "=", e_l_sys) else: s = data[i][24:29] #13: m = np.arange(240, 240 + len(s) * 10, 10) #13 delta, edelta_sys, edelta = stodelta(s, np.ones(len(s)) * e_s) em = np.ones(len(delta)) * e_m ax1, ax2, a, ea, b, eb, chiq, corr = bib.pltmitres(m, delta, edelta, ex=em,
m = np.array([]) s = np.array([]) for i in range(28): s = np.append(s, Rohdaten[i]) m = np.append(m, (i) * 10) s = s * 10**-3 #k=0.04685502878801657 #kerr=7.165372679836135e-05 k = 0.04713889034 kerr = 0.00046389398 yerr1 = (2 * k * serr) yerr2 = (2 * (k - kerr) * serr) yerr3 = (2 * (k + kerr) * serr) print(yerr1) a1, ea1, b1, eb1, chiq1, corr1 = analyse.lineare_regression_xy( m, s * 2 * k, merr, yerr1) print(a1, ea1, b1, eb1, chiq1, corr1) print(chiq1 / 26) a2, ea2, b2, eb2, chiq2, corr2 = analyse.lineare_regression_xy( m, s * 2 * (k - kerr), merr, yerr2) print(a2, ea2, b2, eb2, chiq2, corr2) print(chiq2 / 26) a3, ea3, b3, eb3, chiq3, corr3 = analyse.lineare_regression_xy( m, s * 2 * (k + kerr), merr, yerr3) print(a3, ea3, b3, eb3, chiq3, corr3) print(chiq3 / 26) print(a1 - a2) print(a3 - a1)
logP = np.log(p / p0) Tinv = 1.0 / T # Fehlerfortpflanzung sigma_logP = p_stdabw / p sigma_Tinv = T_stdabw / T**2 # Untermenge fuer lineare Regression T2, p2 = analyse.untermenge_daten(T, p, 1. / 0.00284, 1. / 0.00272) logP2 = np.log(p2 / p0) Tinv2 = 1.0 / T2 sigma_logP2 = p_stdabw / p2 sigma_Tinv2 = T_stdabw / T2**2 a,ea,b,eb,chiq,corr = \ analyse.lineare_regression_xy(Tinv2,logP2,sigma_Tinv2,sigma_logP2) Lambda = -a * scipy.constants.R errLambda = ea * scipy.constants.R print('Lin.Reg.: a=%f+-%f, b=%f+-%f, chi2/ndof=%f/%f, corr=%f' % \ (a,ea,b,eb,chiq,len(Tinv2)-2,corr)) print('Lambda = (%f +- %f) kJ/mol' % (Lambda, errLambda)) figure() errorbar(Tinv, logP, xerr=sigma_Tinv, yerr=sigma_logP, fmt='.') plot(Tinv2, a * Tinv2 + b, '-', color='red', linewidth=3) xlabel('$T^{-1} / \mathrm{K}^{-1}$') ylabel('$\log(p/p_0)$') grid() show()
t1 = np.array( [0.1407, 0.2, 0.2456, 0.284, 0.318, 0.348, 0.3763, 0.4025, 0.427]) t2 = np.array( [0.1408, 0.2, 0.2452, 0.2838, 0.3182, 0.3484, 0.3766, 0.4027, 0.4272]) t12 = t1 * t1 t22 = t2 * t2 # Unsicherheiten sigmas = np.full((9, ), 0.001) sigmatOs = 0.0001 sigmatDz = 0.00029 sigmat2Os = 2 * sigmatOs * t2 sigmat2Dz = 2 * sigmatDz * t1 # Regressionen m1, em1, b1, eb1, chi21, corr1 = analyse.lineare_regression_xy( t12, s, sigmat2Dz, sigmas) print( 'm = (%g +- %g) m/s^2, b = (%g +- %g) m, chi2/dof = %g / %g corr = %g' % (m1, em1, b1, eb1, chi21, len(t12) - 2, corr1)) m2, em2, b2, eb2, chi22, corr2 = analyse.lineare_regression_xy( t22, s, sigmat2Os, sigmas) print( 'm = (%g +- %g) m/s^2, b = (%g +- %g) m, chi2/dof = %g / %g corr = %g' % (m2, em2, b2, eb2, chi22, len(t12) - 2, corr2)) # Residuen fuer die Residuenplots sigmaRes1 = np.sqrt((m1 * sigmat2Dz)**2 + sigmas**2) sigmaRes2 = np.sqrt((m2 * sigmat2Os)**2 + sigmas**2) # Alternative Auswertung m = []
xlabel('s / cm') ylim(0.01, 0.1) legend(title='Abstandsmessung Rohdaten') savefig('Abstandsabh_Rohdaten.pdf', bbox_inches='tight') show() close() ls_B1 = np.log(s_B1) lU_A1 = np.log(U_A1) es = 0.5 / np.sqrt( 12) * 1 / s_B1 #fehler durch schwieriges abmessen und schnelle Kalibration eU = .002 * 1 / (U_A1) # 0.6 / 4096 / np.sqrt(12) * 1/(U_A1) a, ea, b, eb, chiq, corr = analyse.lineare_regression_xy(ls_B1, lU_A1, es, eU) print('Ergebnis: a=%f+-%f, b=%f+-%f, chi2=%f, corr=%f' % (a, ea, b, eb, chiq, corr)) figure() #title('Lineare Regression der Abstandsabhängigkeit') errorbar(ls_B1, lU_A1, xerr=es, yerr=eU, linestyle='none', marker='o', markersize=2, elinewidth=1, zorder=1)
efreq =2*np.pi*np.array([fr[0][1],fr[1][1],fr[2][1],fr[3][1],fr[4][1]]) ''' #Die in schwingung.py bestimmten Frequenzen werden von nun an verwendet: freq = 2 * np.pi * np.array([1696.93, 1696.33, 1695.12, 1689.19, 1628.66]) efreq = 2 * np.pi * np.array([0.599133, 0.695859, 0.991429, 2.12677, 4.84287]) R = np.array([1.008, 5.101, 9.99, 19.82, 46.67]) + 4.93 eR = np.array([0.001, 0.001, 0.002, 0.01, 0.01]) delta = np.array( [341.01810569, 565.81381857, 860.23879874, 1421.9702776, 2820.46265235]) edelta = np.array( [0.25891746, 0.56634525, 1.25160131, 3.57130468, 16.18687673]) k = np.sqrt(freq**2 - delta**2) / (2 * np.pi) reg = analyse.lineare_regression_xy(R**2, freq**2, 2 * eR * R, efreq * freq * 2) ye = 2 * efreq * freq xe = 2 * R * eR f, (ax1, ax2) = plt.subplots(2, 1, sharex='col', gridspec_kw={'height_ratios': [5, 2]}) ax1.plot(R**2, (reg[0] * R**2 + reg[2]), linestyle="--", color='black') ax1.errorbar(R**2, freq**2, yerr=ye, xerr=xe, color='red', fmt='.', marker='o') ax1.grid() ax1.text(0.97, 0.92, s='Steigung: (' + "{0:.2f}".format(reg[0]) + r'$\pm$' + "{0:.2f}".format(reg[1]) + ')1/$\Omega$s',
#Kalibrierung ############################## data = cassy.CassyDaten("Kalibrierung_Wegaufnehmer.lab") s_k = [] R_1 = [] s_k = data.messung(1).datenreihe("s").werte R_k = data.messung(1).datenreihe("R_B1").werte s_1 = np.array(s_k) - np.mean(s_k) R_1 = np.array(R_k) - np.mean(R_k) plt.errorbar(s_1, R_1, yerr=np.ones(len(s_1)) * 0.005 / np.sqrt(12), xerr=np.ones(len(s_1)) * 0.1 / np.sqrt(12), fmt="x") a, ea, b, eb, chiq, corr = anal.lineare_regression_xy( np.array(s_1), np.array(R_1), np.ones(len(s_1)) * 0.1 / np.sqrt(12), np.ones(len(s_1)) * 0.005 / np.sqrt(12)) plt.plot(np.arange(-13, 13, 0.01), a * np.arange(-13, 13, 0.01) + b, label=str(a) + "*x+" + str(b)) print("Parameter a=", a, "b=", b) print("Fehler auf a: s_a=", ea, "; s_b=", eb) print("chiq/Ndf = ", chiq / (len(s_1) - 2)) plt.xlabel("s/cm") plt.ylabel("R/ $\Omega$") plt.title("Kalibriereung des Wegaufnehmers") plt.show() plt.errorbar(s_1, R_1 - a * s_1 - b, np.sqrt(((np.ones(len(s_1)) * 0.005 / np.sqrt(12)))**2 +
reg2minus = np.array([]) #Frequenzen und Dämpfungen bestimmen (Regression) for i in range(1, 6, 1): n = np.arange(1, 1 + dic1[i].size, 1) data = cassy.CassyDaten(dic2[i]) time = data.messung(1).datenreihe('t').werte vol = data.messung(1).datenreihe('U_B1').werte x = time[dic1[i]] ex = np.full((dic1[i].size, ), 1e-05 / np.sqrt(12)) y = np.log(np.abs(vol[dic1[i]]) - dic3[i]) ey = 4.8e-03 * 1 / (np.abs(vol[dic1[i]]) - dic3[i]) ey_sys = 0.01 * np.sqrt(vol[dic1[i]]**2 + dic3[i]**2) / (np.abs(vol[dic1[i]]) - dic3[i]) res1 = analyse.lineare_regression(n, x, ex) res2 = analyse.lineare_regression_xy(x, y, ex, ey) res2plus = analyse.lineare_regression_xy(x, y + ey_sys, ex, ey) res2minus = analyse.lineare_regression_xy(x, y - ey_sys, ex, ey) reg1 = np.concatenate((reg1, res1)) reg2 = np.concatenate((reg2, res2)) reg2plus = np.concatenate((reg2plus, res2plus)) reg2minus = np.concatenate((reg2minus, res2minus)) #Plot f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, sharex='col', gridspec_kw={'height_ratios': [5, 2]}) #1. Regression Vanilla Plot [Zeiten in Mikrosekunden] ax1.plot(n, (res1[0] * n + res1[2]) * 1e+6, linestyle="--", color='black')
else: U_err_array.append(sigmaU) if errI > sigmaI: I_err_array.append(errI) else: I_err_array.append(sigmaI) U_sigma.append(sU) I_sigma.append(sI) #Schleifenende I_array = np.array(I_array) U_array = np.array(U_array) #Widerstand+statistischer Fehler R, eR, b, eb, chiq, corr = ana.lineare_regression_xy(I_array, U_array, np.array(I_err_array), np.array(U_err_array)) x, R, errR_stat = round_good(0.0, R, eR) #systematischer Fehler RUp, eRx, bUp, ebx, chiqUp, corrx = ana.lineare_regression_xy( I_array, U_array + sigma_U_sys(U_array, U_B), np.array(I_err_array), np.array(U_err_array)) RUm, eRx, bUm, ebx, chiqUm, corrx = ana.lineare_regression_xy( I_array, U_array - sigma_U_sys(U_array, U_B), np.array(I_err_array), np.array(U_err_array)) RIp, eRx, bIp, ebx, chiqIp, corrx = ana.lineare_regression_xy( I_array + sigma_I_sys(I_array, I_B), U_array, np.array(I_err_array), np.array(U_err_array)) RIm, eRx, bIm, ebx, chiqIm, corrx = ana.lineare_regression_xy( I_array - sigma_I_sys(I_array, I_B), U_array, np.array(I_err_array),
show() Itot = peakhightR[0] + peakhightT[0] logI = np.log((Itot - peakhightR) / Itot) D = np.array([0.1, 0.4, 1.]) eD = 0.1 / sqrt(12) * np.ones(len(D)) eI = 0.5 * (np.max(peakhightR + peakhightT) - np.min(peakhightR + peakhightT)) * np.ones(len(peakhightR)) elogI = np.ones(3) for i in range(3): elogI[i] = peakhightR[i] * eI[i] / ( Itot - peakhightR[i]) * np.sqrt(1 / (Itot)**2 + 1 / (peakhightR[i])**2) minusk, eminusk, b, eb, chiq, corr = analyse.lineare_regression_xy( D, logI, eD, elogI) print('Ergebnis: a=%f+-%f, b=%f+-%f, chi2=%f, corr=%f' % (minusk, eminusk, b, eb, chiq, corr)) figure() #title('Lin. Reg. zur Bestimmung zur FTIR') errorbar(D, logI, xerr=eD, yerr=elogI, linestyle='none', marker='o', markersize=2, elinewidth=1, zorder=1)
plt.figure() #------------------------------------------------------------ #Berechnung der Verdampfungsenthalpie L_Werte = [[], [], [], []] #L_sys, s_sys, L_stat, s_stat T_Werte = [[], [], []] for i in range(1, 11): xi = np.power(T_real[:1000 * i], -1) - np.power(T_real[0], -1) yi = (-np.log(p)[:1000 * i] + np.log(p[0])) * R sxi_sys = np.sqrt( np.power(T_real[:1000 * i], -4) * sTsys[:1000 * i]**2 + np.power(T_real[0], -4) * sTsys[0]) syi_sys = R * Kalib.sigmap * np.sqrt( np.power(p[:1000 * i], -2) + np.power(p[0], -2)) Lsys, eLsys, bsys, ebsys, chiqsys, corr = ana.lineare_regression_xy( xi, yi, sxi_sys, syi_sys) sxi_stat = np.sqrt( np.power(T_real[:1000 * i], -4) * sTstat[:1000 * i]**2 + np.power(T_real[0], -4) * sTstat[0]) syi_stat = R * Kalib.sigmap * np.sqrt( np.power(p[:1000 * i], -2) + np.power(p[0], -2)) Lstat, eLstat, bstat, ebstat, chiqstat, corr = ana.lineare_regression_xy( xi, yi, sxi_stat, syi_stat) L_Werte[0].append(Lsys) L_Werte[1].append(eLsys) L_Werte[2].append(Lstat) L_Werte[3].append(eLstat) T_Werte[0].append(T_real[1000 * i]) T_Werte[1].append(sTstat[1000 * i]) T_Werte[2].append(sTsys[1000 * i]) print(chiqstat)
mu, inn, aus = gewichtetes_mittel_in_aus(delta_e[i], edelta_e[i]) dele[i][0] = mu dele[i][1] = max(inn, aus) delta1 = np.array([dele[0][0], dele[1][0], dele[2][0], dele[3][0], dele[4][0]]) edelta1 = np.array( [dele[0][1], dele[1][1], dele[2][1], dele[3][1], dele[4][1]]) R = np.array([1.008, 5.101, 9.99, 19.82, 46.67]) eR = np.array([0.001, 0.001, 0.002, 0.01, 0.01]) #Werte aus schwingung.py importieren delta2 = np.array( [341.01810569, 565.81381857, 860.23879874, 1421.9702776, 2820.46265235]) edelta2 = np.array( [0.25891746, 0.56634525, 1.25160131, 3.57130468, 16.18687673]) reg1 = analyse.lineare_regression_xy(R, delta1, eR, edelta1) reg2 = analyse.lineare_regression_xy(R, delta2, eR, edelta2) f, ((ax1, ax3), (ax2, ax4)) = plt.subplots(2, 2, sharex='col', gridspec_kw={'height_ratios': [5, 2]}) ax1.set_title('Regression mit Dämpfungswerten aus Exp-Einhüllende') ax1.plot(R, (reg1[0] * R + reg1[2]), linestyle="--", color='black') ax1.errorbar(R, delta1, yerr=edelta1, xerr=eR, color='red',
def Methode2(): MR0 = np.array([992, 855, 779, 680, 582, 490, 387, 303]) MR1 = np.array([994, 874, 762, 677, 588, 469, 381, 290]) MR2 = np.array([994, 888, 796, 709, 596, 522, 433, 310]) MR3 = np.array([994, 903, 811, 704, 608, 508, 414, 327, 217]) MR4 = np.array([994, 910, 816, 724, 620, 532, 435, 317]) MR5 = np.array([994, 907, 811, 726, 627, 523, 430, 325, 218]) MR6 = np.array([994, 885, 798, 704, 598, 502, 386, 323]) MR = [MR0, MR1, MR2, MR3, MR4, MR5, MR6] figure(figsize=(8, 8)) for i in range(len(MR)): ywerte = MR[i] xwerte = np.array(range(len(MR[i]))) eywerte = eP * np.ones(len(ywerte)) exwerte = em * np.ones(len(xwerte)) name = 'MR' + str(i) #title('Lineare Regression der Abstandskalibrierung') errorbar(x=xwerte, y=ywerte, yerr=eywerte, xerr=exwerte, linestyle='none', marker='o', markersize=4, elinewidth=1, zorder=1, label='Messreihe {}'.format(i)) ylabel('P / hPa') xlabel('m') legend(title='Messwerte Rohdaten') #savefig('Methode2vorKorr.pdf'.format(name), bbox_inches = 'tight') show() P = np.array([]) ePliste = np.array([]) #m=np.array([[0],[0],[0],[0],[0],[0],[0],[0,1]]) for i in range(8): mi = [] for j in range(len(MR)): if len(MR[j]) >= (i + 1): a = MR[j][i] mi.append(a) #m[i]=mi P = np.append(P, np.mean(mi)) ePliste = np.append(ePliste, np.std(mi, ddof=1) / np.sqrt(len(mi))) ePliste[0] = np.mean(ePliste[1:]) #print(m) print(P) print(ePliste) #Lineare Regression ywerte = P xwerte = np.array(range(len(P))) exwerte = em * np.ones(len(xwerte)) eywerte = ePliste name = 'gemittelterDruck' ai, eai, bi, ebi, chiqi, corri = analyse.lineare_regression_xy( xwerte, ywerte, exwerte, eywerte) print( 'a={:.4e}+-{:.4e}, b={:.4e}+-{:.4e}, chi2={:.4e}, corr={:.4e}'.format( ai, eai, bi, ebi, chiqi, corri)) figure() errorbar(x=xwerte, y=ywerte, yerr=eywerte, xerr=exwerte, linestyle='none', marker='o', markersize=4, elinewidth=1, zorder=1) plot(xwerte, ai * xwerte + bi, '-', zorder=2) ylabel('P / hPa') xlabel('m') legend( title= 'Lineare Regression \nSteigung[hPa]: ${:.5f}\\pm{:.5f}$ \ny-Achsenabschnitt[hPa]: ${:.2f}\\pm{:.2f}$ \nDatenpunkte: {}' .format(ai, eai, bi, ebi, len(xwerte))) #savefig('{}_LinReg.pdf'.format(name), bbox_inches = 'tight') show() figure() errorbar(x=xwerte, y=ywerte - (ai * xwerte + bi), yerr=np.sqrt(eywerte**2 + (exwerte * ai)**2), linestyle='none', marker='o', markersize=4, elinewidth=1, zorder=1) plot(xwerte, 0. * xwerte, zorder=2) # Linie bei Null xlabel('m') ylabel('P - P(Fitgerade) [hPa]') legend(title='Residuenplot \n $X^2/n_{{df}}$ = {:.2f}'.format( chiqi / (len(xwerte) - 2))) #savefig('{}_Residuen.pdf'.format(name), bbox_inches = 'tight') show() NP = lambdag / (2 * L * (-1) * ai) # NP = Delta N / Delta P eNP_stat = lambdag / (2 * L * (-1) * a**2) * eai eNP_sys = elambdag / (2 * L * (-1) * ai) print( 'gemittelte Drücke: NP={:.3f}e-7 +- {:.3f}e-7(stat) +- {:.3f}e-7 (sys)' .format(NP * 10**7, eNP_stat * 10**7, eNP_sys * 10**7))
def Rohdaten(): MR0 = np.array([992, 855, 779, 680, 582, 490, 387, 303]) MR1 = np.array([994, 874, 762, 677, 588, 469, 381, 290]) MR2 = np.array([994, 888, 796, 709, 596, 522, 433, 310]) MR3 = np.array([994, 903, 811, 704, 608, 508, 414, 327, 217]) MR4 = np.array([994, 910, 816, 724, 620, 532, 435, 317]) MR5 = np.array([994, 907, 811, 726, 627, 523, 430, 325, 218]) MR6 = np.array([994, 885, 798, 704, 598, 502, 386, 323]) MR = [MR0, MR1, MR2, MR3, MR4, MR5, MR6] for i in range(8): print("{}&{}&{}&{}&{}&{}&{}&{}\\".format(i, MR0[i], MR1[i], MR2[i], MR3[i], MR4[i], MR5[i], MR6[i])) a = np.array([]) ea = np.array([]) b = np.array([]) eb = np.array([]) chiq = np.array([]) for i in range(len(MR)): ywerte = MR[i] xwerte = np.array(range(len(MR[i]))) eywerte = eP * np.ones(len(ywerte)) exwerte = em * np.ones(len(xwerte)) name = 'MR' + str(i) ai, eai, bi, ebi, chiqi, corri = analyse.lineare_regression_xy( xwerte, ywerte, exwerte, eywerte) print('\n\n\n\nMessreihe {}'.format(i)) print('a={:.4e}+-{:.4e}, b={:.4e}+-{:.4e}, chi2={:.4e}, corr={:.4e}'. format(ai, eai, bi, ebi, chiqi, corri)) print('damit waere delta_n/delta_p={} 1/hPa'.format( lambdag / (2 * 0.01 * (-ai)))) a = np.append(a, ai) ea = np.append(ea, eai) b = np.append(b, bi) eb = np.append(eb, ebi) chiq = np.append(chiq, chiqi) figure(figsize=(6, 4)) errorbar(x=xwerte, y=ywerte, yerr=eywerte, xerr=exwerte, linestyle='none', marker='o', markersize=4, elinewidth=1, zorder=1) plot(xwerte, ai * xwerte + bi, '-', zorder=2) ylabel('P / hPa') xlabel('m') legend( title= 'Lineare Regression \nSteigung[hPa]: ${:.1f}\\pm{:.1f}$ \ny-Achsenabschnitt [hPa]: ${:.0f}\\pm{:.0f}$ \nDatenpunkte: {}' .format(ai, eai, bi, ebi, len(xwerte))) if (i == 0) or (i == 1): savefig('{}_LinReg_Druck.pdf'.format(name), bbox_inches='tight') show() figure(figsize=(6, 2)) errorbar(x=xwerte, y=ywerte - (ai * xwerte + bi), yerr=np.sqrt(eywerte**2 + (exwerte * ai)**2), linestyle='none', marker='o', markersize=4, elinewidth=1, zorder=1) plot(xwerte, 0. * xwerte, zorder=2) # Linie bei Null xlabel('m') ylabel('P - P(Fitgerade) [hPa]') legend(title='Residuenplot \n $X^2/n_{{df}}$ = {:.2f}'.format( chiqi / (len(xwerte) - 2))) if (i == 0) or (i == 1): savefig('{}_Residuen_Druck.pdf'.format(name), bbox_inches='tight') show() NP = lambdag / (2 * L * (-1) * a) # NP = Delta N / Delta P eNP_stat = lambdag / (2 * L * a**2) * ea eNP_sys = elambdag / (2 * L * (-1) * a) for i in range(len(NP)): print( 'Messreihe {}: NP={:.3f}e-7 +- {:.3f}e-7(stat) +- {:.3f}e-7 (sys)' .format(i, NP[i] * 10**7, eNP_stat[i] * 10**7, eNP_sys[i] * 10**7)) for i in range(len(NP)): print('{}&{:.2f}&${:.1f}\\pm{:.1f}$&{:.3f}&{:.3f}&{:.3f}\\\\'.format( i, chiq[i] / (len(MR[i]) - 2), a[i] * (-1), ea[i], NP[i] * 10**7, eNP_stat[i] * 10**7, eNP_sys[i] * 10**7)) figure() errorbar(x=range(7), y=NP, yerr=eNP_stat, linestyle='none', marker='o') ylabel('$\\Delta n / \\Delta P$ [1/hPa]') xlabel('MR') ticklabel_format(useMathText=True) savefig('Methode1_Ergebnisse.pdf'.format(name), bbox_inches='tight') show() NP_mean, eNP_stat_mean = analyse.gewichtetes_mittel(NP, eNP_stat) eNP_sys_mean = max(eNP_sys) print( 'Ergebnis nach gewichtetes Mittel: NP = {:.3f}e-7 +- {:.3f}e-7(stat) +-{:.3f}e-7(sys), SigmaUmgebung={:.1f}' .format(NP_mean * 10**7, eNP_stat_mean * 10**7, eNP_sys_mean * 10**7, (NP_mean * 10**7 - 2.655) / ((np.sqrt(eNP_stat_mean**2 + eNP_sys_mean**2)) * 10**7)))
# Grafische Darstellung der Rohdaten subplot(2, 1, 1) errorbar(I, U, xerr=sigmaI, yerr=sigmaU, color='red', fmt='.', marker='o', markeredgecolor='red') xlabel('$I$ / A') ylabel('$U$ / V') # Lineare Regression R, eR, b, eb, chiq, corr = analyse.lineare_regression_xy(I, U, sigmaI, sigmaU) print( 'R = (%g +- %g) Ohm, b = (%g +- %g) V, chi2/dof = %g / %g corr = %g' % (R, eR, b, eb, chiq, len(I) - 2, corr)) plot(I, R * I + b, color='green') # Residuen subplot(2, 1, 2) # Für den Residuenplot werden die Beiträge von Ordinate und Abszisse (gewichtet mit der Steigung) quadratisch addiert. sigmaRes = np.sqrt((R * sigmaI)**2 + sigmaU**2) errorbar(I, U - (R * I + b), yerr=sigmaRes, color='red', fmt='.', marker='o',
#Daten einlesen data = cassy.CassyDaten("Kalibrierung_Wegaufnehmer.lab") n = np.array(data.messung(1).datenreihe("n").werte) #Nummer des Messpunktes, wobei n=1 der weiteste Abstand war R = np.array(data.messung(1).datenreihe("R_B1").werte) #Widerstand in kOhm #n->L L=(5*len(n)-5*(n)) #in cm #es wurde in 5cm-Schritten gemessen #TODO: np.arange(0.5,30.5,5) #So ist L=0 bei der Messung, die am nächsten an der Quelle war und L wird bei größerem Abstand von der Quelle größer L_err=np.ones(len(L))*0.1/2 #cm R_err=np.ones(len(R))*0.005/np.sqrt(12) #kOhm L_esys=0.03+0.02*1 #cm #Güteklasse II:a+b*L mit a=0.3mm, b=0.2mm/m, L= auf ganzen Meter gerundete zu messende Länge #=const. #lineare Regression k,k_err,L0,L0_err,chiq,corr=analyse.lineare_regression_xy(R,L,R_err,L_err) chiq,k,k_err=Temperatur.round_good(chiq,k,k_err) x,L0,L0_err=Temperatur.round_good(0,L0,L0_err) if __name__=='__main__': print('\nRegression L=R*x+L0=({} +- {})cm/kOhm * R+({} +- {})cm'.format(k,k_err,L0,L0_err)) #Plot: Messpaare und Regression plt.title('Regression: Kalibrierung') plt.errorbar(R,L,xerr=R_err,yerr=L_err,fmt='ko', label=u'Messpaare Chi²/f={}/{} ≈ {}'.format(chiq,len(R)-2,np.round(chiq/(len(R)-2),2))) x=np.arange(min(R),max(R),0.001) plt.plot(x,k*x+L0,label=r'$k*R+L_0=({}\pm{})cm/k\Omega * R+({}\pm{})cm$'.format(k,k_err,L0,L0_err)) plt.xlabel(r'Widerstand R/k$\Omega$') plt.ylabel('Länge L/cm') plt.legend() plt.savefig('Images/Kalibrierung_Regression.pdf')
def pltmitres(x,y,ey,ex=0, xlabel="x", ylabel="y", xunit="", yunit="", title="", ratios=[2,1], regdata =False, precision=2,capsize=5, markersize=5): """ Erstellen eines Plots mit dazugehörigem Residumplot Parameter --------- x,y,ex,ey: Daten mit Fehler (ex optionell) xlabel,ylabel: Titel der Achsen xunit,yunit: Einheit der Werte als String title: Titel des Plots ratios: Flächenverhältnis zwischen Daten- und Residumplot regdata : Falls wahr, a,ea,b,eb,chiq,corr der Regression werden auch zurückgegeben precision: Nachkommastellen der Parameter a,b Returns -------- ax : Achsen des Datenplots (0) bzw. Residumplots (1) (a, ea), (b,eb),chiq,corr: Ergebnisse der linearen Regression (falls regdata = True) Verwendung ---------- >>> import numpy as np >>> import praktikum_addons.bib as bib >>> import matplotlib.pyplot as plt >>> x = np.arange(0.1,1.3,0.1) >>> y = np.sin(x) >>> ex = np.ones(len(x))*0.03 >>> ey = np.ones(len(y))*0.1 >>> ax = bib.pltmitres(x,y, ex, ey, yunit = "s", xunit="m", ratios=[7,1]) >>> ax[0].set_ylim(top=2) >>> plt.show() """ x = np.array(x) y = np.array(y) ex = np.array(ex) ey = np.array(ey) if ex.all()==0: a,ea,b,eb,chiq,corr = anal.lineare_regression(x,y,ey) else: a,ea,b,eb,chiq,corr = anal.lineare_regression_xy(x,y,ex,ey) fig, (ax1,ax2) = plt.subplots(2, 1,gridspec_kw = {'height_ratios':ratios}) ax1.set_title(title) ax1.errorbar(x,y, ey, np.ones(len(x))*ex, marker="x", linestyle="None", capsize=capsize, markersize=markersize) l = max(x)-min(x) x2 = np.arange(min(x)-l*0.1, max(x)+l*0.1, l/1000) y2 = a*x2+b ax1.plot(x2, y2, color="orange") if yunit!="": ax1.set_ylabel(ylabel+" [{}]".format(yunit)) else: ax1.set_ylabel(ylabel) ax1.legend(title="Lineare Regression\n{1} = ({2:.{0}f} ± {3:.{0}f}){4} $\cdot$ {5}+({6:.{0}f}±{7:.{0}f}){8}\n$\chi^2 /NDF={9:.4f}$".format(precision,ylabel,a,ea, yunit+"/"+xunit,xlabel,b, eb, yunit, chiq/(len(x)-2)), loc=1) ax2.errorbar(x,y-a*x-b, np.sqrt(ex**2*a**2+ey**2), marker="x", linestyle="None", capsize=capsize, markersize=markersize) ax2.axhline(0, color="orange") if xunit!="": plt.xlabel(xlabel+" [{}]".format(xunit)) else: plt.xlabel(xlabel) plt.tight_layout() if regdata : return (ax1, ax2), (a,ea),(b,eb),chiq,corr else: return (ax1, ax2)
show() close() #-----------------------------Lineare Regresion---------------------------------- eR=3/4096/sqrt(12)*np.ones(len(R)) #Binningfehler auf Widerstand in kOhm ed=0.03*np.ones(len(d))#/sqrt(12)*np.ones(len(d)) #Ablesefehler Maßband in cm d_mean=np.mean(d) R_mean=np.mean(R) a,ea,b,eb,chiq,corr = analyse.lineare_regression_xy(R-R_mean,d-d_mean,eR,ed) print('Ergebnis: a=%f+-%f, b=%f+-%f, chi2=%f, corr=%f' % (a,ea,b,eb,chiq,corr)) def AbstandausW(Omega): return a*(Omega-R_mean)+b+d_mean figure() #title('Lineare Regression der Abstandskalibrierung') errorbar(R, d, xerr=eR, yerr=ed, linestyle='none', marker='o', markersize=4, elinewidth=1, zorder=1) plot(R, AbstandausW(R),'-', zorder=2) xlabel('R / $k\\Omega$') ylabel('S / cm') legend(title='Lineare Regression \nSteigung [cm/k$\\Omega$]: ${:.3f}\\pm{:.3f}$ \ny-Achsenabschnitt[cm]: ${:.1f}\\pm{:.1f}$ \nDatenpunkte: {}'.format(a, ea, b, eb, len(R-R_mean))) savefig('WegaufKal_LinReg.pdf', bbox_inches = 'tight')
close() #systematische Fehler auf s in cm esyss = sqrt(eS0**2 + (eK * (R1 - R0))**2) #Lineare Regression x = np.array(np.log(s1)) y = np.array(np.log(U1)) ex = np.array(es1 / s1) ey = np.array(eU1 / U1) xl = "log(s/cm)" yl = "log(U/V)" xeinheit = "" yeinheit = "" a, ea, b, eb, chiq, corr = anal.lineare_regression_xy(x, y, ex, ey) plt.errorbar(x, y, ey, ex, marker="x", linestyle="None", capsize=5) l = max(x) - min(x) x2 = np.arange(min(x) - l * 0.1, max(x) + l * 0.1, l / 1000) y2 = a * x2 + b plt.plot(x2, y2, color="orange") plt.xlabel(xl + " [{}]".format(yeinheit)) plt.ylabel(yl + " [{}]".format(xeinheit)) plt.legend( title= "Lineare Regression\n{} = ({:.2f} ± {:.2f}){} $\cdot$ {}+({:.2f}±{:.2f}){}\n$\chi^2 /NDF={:.2f}$" .format(yl, a, ea, xeinheit, xl, b, eb, yeinheit, chiq / (len(x) - 2)), loc=1) plt.savefig('Abstand3_LinReg.pdf', bbox_inches='tight') plt.show()
plt.ylabel("Temperatur in K") plt.xlabel("Zeit in s") plt.show() plt.plot(t, p) plt.title("Dampfdruckänderung im Kolben") plt.ylabel("Druck in Pa") plt.xlabel("Zeit in s") plt.show() L_Werte=[[],[]] T_Werte=[[],[]] for i in range(1,11): xi=np.power(T[:1000*i], -1)-np.power(T[0], -1) yi=(-np.log(p)[:1000*i]+np.log(p[0]))*R L,eL,b,eb,chiq,corr = anal.lineare_regression_xy(xi, yi, np.ones(len(xi)), np.ones(len(yi))) L_Werte[0].append(L) L_Werte[1].append(eL) T_Werte[0].append(T[1000*i]) T_Werte[1].append(1) L,eL,b,eb,chiq,corr = anal.lineare_regression_xy(np.array(T_Werte[0]), np.array(L_Werte[0]), np.array(T_Werte[1]), np.array(L_Werte[1])) plt.plot(T_Werte[0], L_Werte[0]) x=np.arange(min(T_Werte[0])-2,max(T_Werte[0])+2,0.01) plt.plot(x, L*x+b) plt.title("Lamda in Abhängigkeit von T") plt.show() print("Tabelle von Werten") print("L || T") for i in range(1,11): print(str(T_Werte[0][i-1]) + " || " + str(L*T_Werte[0][i-1]+b))
plt.xlabel('Zeit/s') plt.plot(t, np.array([np.mean(T)] * len(t)), color='darkorange') plt.savefig("Images/Rauschmessung_{}.pdf".format(dnames[i])) plt.figure() ts.append(t) Ts.append(mT) T_errs.append(max(errT, dig)) #Versuch einer linearen Regression (Vorschlag) #t1=17:05,t2=18:31, t3=19:45 zeiten = np.array([0, 86, 160]) #min Ts = np.log(np.array(Ts)) T_errs = np.array(T_errs) / np.array(Ts) zeiten_err = np.ones(len(zeiten)) * 1 / 60 c, c_err, b, b_err, chiq, corr = analyse.lineare_regression_xy( zeiten, Ts, T_errs, zeiten_err) #Plot if __name__ == '__main__': #print('\nErwärmung: {2}°C/min'.format(*round_good(0,0,c))) x = np.arange(min(zeiten), max(zeiten), 0.1) plt.errorbar(zeiten, Ts, yerr=T_errs, fmt='ko') #eher exponentiell... plt.plot(x, c * x + b, color='red') plt.xlabel('t/min') plt.ylabel(u'log(T/°C)') plt.title('Temperaturverlauf während der Versuchsreihe') plt.savefig('Images/Temperatur_Verlauf.pdf') plt.figure() print(u'Chi²/f =', chiq, '/1')
#title('Winkelaufnehmer: Rohdaten') scatter(R, gamma, marker="o") xlabel('R / k$\\Omega$') ylabel('$\\gamma$ / Grad') legend(title='Rohdaten Winkelkalibrierung') savefig('Winkelkal_Rohdaten.pdf', bbox_inches='tight') show() close() eR = 10. / 4096. / np.sqrt(12) * np.ones(len(R)) egamma = 5 / np.sqrt(12) * np.ones(len(gamma)) * np.pi / 180 gamma_mean = np.mean(gamma) R_mean = np.mean(R) K_winkel, eK_winkel, b, eb, chiq, corr = analyse.lineare_regression_xy( R - R_mean, gamma - gamma_mean, eR, egamma) print('Ergebnis: a=%f+-%f, b=%f+-%f, chi2=%f, corr=%f' % (K_winkel, eK_winkel, b, eb, chiq, corr)) def AbstandausW(Omega): return K_winkel * (Omega - R_mean) + b + gamma_mean figure() #title('Lineare Regression der Winkelkalibrierung') errorbar(R, gamma * 180 / np.pi, xerr=eR, yerr=egamma * 180 / np.pi,
return np.array(R_kn) f = 1608.56165094 s_f = 0.67901543 s_R = 0.005 / np.sqrt(12) data = cassy.CassyDaten("Kalibrierung_Wegaufnehmer.lab") s_k = [] R_1 = [] s_k = data.messung(1).datenreihe("s").werte R_k = data.messung(1).datenreihe("R_B1").werte s_1 = np.array(s_k) - np.mean(s_k) R_1 = np.array(R_k) - np.mean(R_k) a, ea, b, eb, chiq, corr = anal.lineare_regression_xy( np.array(s_1), np.array(R_1), np.ones(len(s_1)) * 0.1 / np.sqrt(12), np.ones(len(s_1)) * 0.005 / np.sqrt(12)) def R_to_s(R): return (R - b - np.mean(R_k) + np.mean(s_k) * a) / a R, U = c_open("V2.1C.lab") #finde die Knoten R_peak = finde_Knoten(R, U) s_peak = R_to_s(R_peak) s_s_peak = s_R / a * np.ones(len(s_peak)) s_sys_s = np.sqrt((R_peak / a**2) * ea**2) #ist der sys. Fehler auf R bekannt? for r in R_peak: plt.axvline(r)
plt.title("Temperatur bei T=0°C\n s=" + str(sigmaT0) + ", m=" + str(T0)) plt.plot(np.arange(min(t_sliced), max(t_sliced), 0.1), np.ones(len(t_sliced)) * T0, color="green") plt.plot(t_sliced, T) plt.show() x = np.arange(min(T), max(T), 0.01) plt.hist(T, normed=True) plt.plot(x, gauss(x, np.average(T), np.std(T))) plt.title("Streuung der gemessten Temperaturwerte bei T=0°C") plt.show() #=>> mehr oder weniger Gauß ->man kann den Durchschnitt nehmen... plt.plot(t, p) m, em, b, eb, chiq, corr = anal.lineare_regression_xy(t, p, sigmat * np.ones(len(t)), sigmap * np.ones(len(p))) plt.plot(t, m * t + b, color='green') plt.title("Dichtigkeitsmessung aka Druncksanstieg im evakuierten Kolben") plt.show() print( 'm = (%g +- %g) Pa/s, b = (%g +- %g) Pa, chi2/dof = %g / %g corr = %g' % (m, em, b, eb, chiq, len(t) - 2, corr)) #T=100°C: data = cassy.CassyDaten("Temperatur, Druck bei 100.lab") t = data.messung(1).datenreihe("t").werte p = data.messung(1).datenreihe("p_B1").werte T = data.messung(1).datenreihe("&J_A11").werte N_slice = [
#Plot k gegen l plt.figure() plt.errorbar(l_F, ks, yerr=errks, xerr=errl_F, fmt='ko') plt.xlabel('Abstand der Feder von der Pendelachse $l_F$ in cm') plt.ylabel('Kopplungsgrad $k$') plt.title('Abhängigkeit des Kopplungsgrades vom Drehachsenabstand') plt.grid() plt.savefig('Images/Gekoppelt_Kopplung') #Lineare Regression zu Bestimmung von D ks = np.array(ks) errx = np.array(errks / ks**2) erry = m * g * l_s / (l_F / 100)**2 * 2 * errl_F / (l_F / 100) D, errD, b, errb, chiq, corr = analyse.lineare_regression_xy( 1 / ks - 1, m * g * l_s / (l_F / 100)**2, errx, erry) print('Federkonstante:(', D, '+-', errD, ')N/m, Chi²/f=', chiq / 2) #TODO: Chi² zu klein #Regressionsplot plt.figure() plt.errorbar(1 / ks - 1, m * g * l_s / (l_F / 100)**2, yerr=erry, xerr=errx, fmt='ko') steps = np.arange(min(1 / ks - 1), max(1 / ks - 1), 0.001) plt.plot(steps, D * steps + b, color='red') plt.ylabel('$m*g*l_s/l_F^2$ in N/m') plt.xlabel('$1/k-1$') plt.title('Regression zur Berechnung von D')
# 9 m = np.array([ 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 ]) for i in range(len(s)): if (i != 0): m[i] = m[i - 1] + m[i] xwerte = m ywerte = s exwerte = merr * np.ones(len(xwerte)) eywerte = serr * np.ones(len(ywerte)) name = "Uebersetzungsfaktor2" a, ea, b, eb, chiq, corr = analyse.lineare_regression_xy( xwerte, ywerte, exwerte, eywerte) print('a={:.4e}+-{:.4e}, b={:.4e}+-{:.4e}, chi2={:.4e}, corr={:.4e}'.format( a, ea, b, eb, chiq, corr)) print('somit ist der Umrechnungsfaktor k={}+-{}'.format( 1000 * lambdaHeNe / (2 * a), 1000 * ea * lambdaHeNe / (2 * a**2))) def anpassung(x): return a * (x) + b figure() errorbar(x=xwerte, y=ywerte, yerr=eywerte, xerr=exwerte,
w_35, ew_35 = mittel(groesse, '35') w_40, ew_40 = mittel(groesse, '40') w_45, ew_45 = mittel(groesse, '45') w_50, ew_50 = mittel(groesse, '50') ew = np.array([ew_20, ew_25, ew_30, ew_35, ew_40, ew_45, ew_50]) w = np.array([w_20, w_25, w_30, w_35, w_40, w_45, w_50]) x = 1 / (w**2) ex = ew / (w**3) hoehen = np.array([0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5]) y = V + A * hoehen ey = np.sqrt(2 * (em / rho_h20)**2 + (ed * np.pi * d / 2 * hoehen)**2 + (A * ex0)**2) #Regression für V res = analyse.lineare_regression_xy(x, y, ex, ey) fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(12, 6), gridspec_kw={'height_ratios': [5, 2]}) ax1.plot(x, res[0] * x + res[2], linestyle="--", color='black') err = np.sqrt((ex * res[0])**2 + ey**2) ax1.errorbar(x, y, yerr=err, color='red', fmt='.', marker='o', markeredgecolor='red') ax2.errorbar(x,