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,
