def absorb_zink(a, b, c, d, Z, winkel, imp, x_p, x_m, y_p, y_m, name):
###Peak detect
kante = winkel[c + 2] + 0.5 * (winkel[c + 6] - winkel[c + 2])
energie_k = brag_ener(kante, 1) * 1e-3
sigma = absorbkoe(energie_k * 1e3, Z)
print('Betrachte: ', name)
print('winkel_min', winkel[c + 2])
print('winkel_max', winkel[c + 6])
print('Winkel K Kante', kante)
print('Energie K Kante', energie_k)
print('Abschirmkoef', sigma)
print('\n\n\n')
plt.clf()
plt.plot(winkel, imp, 'rx', label=r'$Intensität$')
#plt.axvline(winkel_max,ls='--', color='b',label=r'$\theta_{\mathrm{max}}$')
#plt.axvline(winkel_min,ls='--', color='g',label=r'$\theta_{\mathrm{min}}$')
plt.xlabel(r'$\theta \, \mathrm{in} \, \mathrm{deg}$')
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$')
plt.grid()
plt.xlim(winkel[0] - x_m, winkel[-1] + x_p)
plt.ylim(min(imp) - y_m, max(imp) + y_p)
plt.legend(loc='best', )
plt.axes([0.207, 0.375, 0.3, 0.3])
plt.plot(winkel[c:d], imp[c:d], 'rx')
plt.title(r'$\mathrm{Vergrößerung \, der \, K-Kante}$')
plt.xlim(winkel[c] - x_m, winkel[d] + x_p)
plt.axvline(winkel[c + 6],
ls='--',
color='b',
label=r'$\theta_{\mathrm{max}}$')
plt.axvline(winkel[c + 2],
ls='--',
color='g',
label=r'$\theta_{\mathrm{min}}$')
plt.ylim(imp[c] - 15, imp[d] - 20)
plt.legend(loc='best', fontsize=12)
plt.grid()
#plt.xticks([0, -0.1 , -0.2, -0.3], ['0', '-0.1', '-0.2', '-0.3'])
#plt.yticks([0, 0.02 , 0.04 , 0.06,0.08, 0.1, 0.12, 0.14 ], ['0', '0.02', '0.04','0.06', '0.08' , '0.1', '0.12', '0.14'])
plt.savefig(name + '.pdf')
l.Latexdocument(name + '.tex').tabular(
[winkel, imp],
'{$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$}',
[2, 0],
caption=
'Messwerte bei der Untersuchung des Absorptionsspektrums von $\ce{Zn}$.',
label=name)
return energie_k
def absorb(a, b, Z, winkel, imp, x_p, x_m, y_p, y_m, name):
###Peak detect
maxi = max(imp[a:b])
winkel_max = winkel[a:b][np.where(imp[a:b] == maxi)]
mini = min(imp[a:b])
winkel_min = winkel[a:b][np.where(imp[a:b] == mini)]
kante = winkel_min + 0.5 * (winkel_max - winkel_min)
energie_k = brag_ener(kante, 1) * 1e-3
sigma = absorbkoe(energie_k * 1e3, Z)
print('Betrachte: ', name)
print('winekl min', winkel_min)
print('winkel_max', winkel_max)
print('Winkel K Kante', kante)
print('Energie K Kante', energie_k)
print('Abschirmkoef', sigma)
print('\n\n\n')
plt.clf()
plt.plot(winkel, imp, 'rx', label=r'$Intensität$')
plt.axvline(winkel_max,
ls='--',
color='b',
label=r'$\theta_{\mathrm{max}}$')
plt.axvline(winkel_min,
ls='--',
color='g',
label=r'$\theta_{\mathrm{min}}$')
plt.grid()
plt.xlabel(r'$\theta \, \mathrm{in} \, \mathrm{deg}$', size=25)
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$', size=25)
plt.xlim(winkel[0] - x_m, winkel[-1] + x_p)
plt.ylim(min(imp) - y_m, max(imp) + y_p)
plt.legend(loc='best', fontsize=20)
plt.savefig(name + '.pdf')
l.Latexdocument(name + '.tex').tabular(
[winkel, imp],
'{$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$}',
[2, 0],
caption=
'Messwerte bei der Untersuchung des Emmissionspektrums von $\ce{Cu}$.',
label=name)
return energie_k
def auswertung_brag(winkel, inten, x_p, x_m, y_p, y_m, name):
l.Latexdocument(name + '.tex').tabular(
[
winkel[0:len(winkel) // 2], inten[0:len(winkel) // 2],
winkel[len(winkel) // 2 + 1:], inten[len(winkel) // 2 + 1:]
],
'{$\\alpha_{\mathrm{Gl}} \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$} & {$\\alpha_{\mathrm{Gl}} \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$}',
[1, 0, 1, 0],
caption='Messwerte bei der Untersuchung der Bragg Bedingung.',
label='bragg_test')
plt.clf()
plt.plot(winkel, inten, 'rx', label=r'$Intensität$')
plt.axvline(winkel[np.argmax(inten)],
ls='--',
color='b',
label=r'$Maximum$')
plt.grid()
plt.xlabel(r'$2 \theta \, \mathrm{in} \, \mathrm{deg}$')
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$')
plt.xlim(winkel[0] - x_m, winkel[-1] + x_p)
plt.ylim(min(inten) - y_m, max(inten) + y_p)
plt.legend(loc='best')
plt.savefig(name + '.pdf')
return winkel[np.argmax(inten)]
print('Gerade B(I) Paramter: ', params_B)
I_lim = np.linspace(-0.2, 5.2, 100)
plt.plot(I_eich_steigend, B_eich_steigend, 'bx', label='Messwerte steigender Strom')
plt.plot(I_eich_fallend, B_eich_fallend, 'rx', label='Messwerte fallender Strom')
plt.plot(I_lim, F_1(I_lim, *params_1), '-b', label='Lineare Regression')
plt.xlim(I_eich_steigend[0], I_eich_steigend[-1])
plt.xlabel('$I$ in $A$')
plt.ylabel('$B$ in $mT$')
plt.ylim(-1500, 500)
plt.xlim(I_lim[0], I_lim[-1])
plt.grid()
plt.legend(loc='best')
plt.savefig('hysterese.pdf')
latex.Latexdocument('hysterese_tab.tex').tabular([I_eich_steigend, B_eich_steigend, B_eich_fallend[::-1] ],
'{$I_q$ in $\si{\\ampere}$} & {$B_{wachsend}$ in $\si{\milli \\tesla}$} & {$B_{fallend}$ in $\si{\milli \\tesla}$}', [1, 1, 1] ,
caption = 'Messung des magnetischen Feldes bei fallendem und steigendem Strom', label = 'tab: hysterese')
def B(I):
return Q_(params_1[0] * I + params_1[1], 'millitesla')
#Bestimmung Widerstand
I_zink_raw, U_zink_raw = np.genfromtxt('uri_zink.txt', unpack=True)
I_zink = Q_(I_zink_raw, 'ampere')
U_zink = Q_(U_zink_raw, 'millivolt')
params_zink_R, cov_zink_R = curve_fit(F_1, I_zink.magnitude, U_zink.magnitude, sigma=0.1)
plt.clf()
I_lim = np.linspace(-0.2, 8.2, 100)
plt.plot(I_zink.magnitude, U_zink.magnitude, 'rx', label='Messwerte')
plt.plot(I_lim, F_1(I_lim, *params_zink_R), '-b', label='Lineare Regression')
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
from pint import UnitRegistry
import scipy.constants as const
import latex as l
r = l.Latexdocument('plots.tex')
u = UnitRegistry()
Q_ = u.Quantity
import pandas as pd
from pandas import Series, DataFrame
from scipy.signal import find_peaks
# Import measurment datas
channel_content_ca = np.genfromtxt('./2018-10-29_becker_grisard/caesium.txt',
unpack=True)
# --- Import params to transform binnumber to energy ---#
params, errors = np.genfromtxt('./umrechnungen_bins_to_energy.txt',
unpack=True)
m = ufloat(params[0], errors[0])
b = ufloat(params[1], errors[1])
def g(x, m, b):
return m * x + b
print('RC in Teil a',1/params_a_u)
print('\n')
def ger (x,m,b):
return m*x+b
params_a2,covariance_a2=curve_fit(ger,t,np.log(u_a))
error_params_a2=np.sqrt(np.diag(covariance_a2))
print(params_a2)
print(error_params_a2)
params_a_u=ufloat(params_a2[0],error_params_a2[1])
print('RC in Teil a, linearer Fit',1/params_a_u)
print('\n')
latex.Latexdocument('abgelesene_werte_teila.tex').tabular([t, u_a],
r'{$t$ in $\si{\milli\second}$} & {$U\ua{ein}$ in $\si{\volt}$}', [1, 1],
caption = r'Aus der Grafik \ref{fig:entladekurve} bestimmte Messwerte', label = 'tab:teil_a_spannungen')
##teilb
f, u_c, u_g = np.genfromtxt('u_c_und_u_g.txt',unpack=True)
f= f*u.hertz
u_c= 0.5*u_c* u.volt
u_g =0.5*u_g* u.volt
u_c_normierung=u_c/u_g
print('Verhältnis Uc/Ug', u_c_normierung)
print('\n')
def fit(x,a):
return 1/(np.sqrt(1+(2*np.pi*x)**2*a**2))
r'$\sqrt{I_{\mathrm{p}}} \, \, \mathrm{in} \, \, \sqrt{\mathrm{nA}}$',
size=25)
#plt.show()
plt.savefig(name + '.pdf')
return messwerte
###Gelb
result_gelb = auswertung((-1) * u_gelb_brems, i_gelb_brems, 'gelbem', 0.08,
0.01, 0.1)
l.Latexdocument('gelb.tex').tabular(
[(-1) * u_gelb_brems.magnitude, i_gelb_brems.magnitude,
np.sqrt(i_gelb_brems.magnitude)],
'{Bremsspannung $U$ in $\si{\\volt}$} & {Photostrom $I_{\map{p}}$ in $\si{\\nano\\ampere}$} & {Photostrom $\sqrt{I_{\map{p}}}$ in $\sqrt{\si{\\nano\\ampere}}$}',
[3, 3, 3],
caption='Gemessener Photostrom bei gelbem Licht',
label='gelb')
l.Latexdocument('gelb_all.tex').tabular(
[u_gelb.magnitude, i_gelb.magnitude],
'{Spanung $U$ in $\si{\\volt}$} & {Photostrom $I_{\map{p}}$ in $\si{\\nano\\ampere}$}',
[3, 3],
caption='Gemessener Photostrom bei gelbem Licht',
label='gelb_all')
### grün
u_gruen, i_gruen = np.genfromtxt('grün.txt', unpack=True)
u_gruen = Q_(u_gruen, 'volt')
i_gruen = Q_(i_gruen, ' nanoampere')
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
import math
from scipy.optimize import curve_fit
from pint import UnitRegistry
import latex as l
r = l.Latexdocument('results.tex')
u = UnitRegistry()
Q_ = u.Quantity
import os
from tab2tex import make_table
def abs_path(filename):
return os.path.join(os.path.dirname(__file__), filename)
import matplotlib as mlp
mlp.use('pgf')
import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.family'] = 'serif'
rcParams['font.serif'] = '[lmroman10-regular]:+tlig;'
rcParams['text.usetex'] = True
rcParams['pgf.texsystem'] = 'lualatex'
rcParams['font.size'] = 10
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
import math
from scipy.optimize import curve_fit
from pint import UnitRegistry
import latex as l
r = l.Latexdocument('results.tex')
u = UnitRegistry()
Q_ = u.Quantity
import os
from scipy.integrate import quad
from pandas import DataFrame
from scipy.interpolate import interp1d
from tab2tex import make_table
def abs_path(filename):
return os.path.join(os.path.dirname(__file__), filename)
def noise(y):
error_y = np.random.normal(0, 0.01, size=len(y))
return y + error_y
import matplotlib as mlp
mlp.use('pgf')
def weg_lambda(weg, anzahl):
return (2 * weg) / (anzahl)
wellenlänge = weg_lambda(weg, anzahl_weg)
wellenlänge_u = unp.uarray(np.mean(wellenlänge),
np.std(wellenlänge) / np.sqrt(len(wellenlänge)))
print('Wellenlänge', wellenlänge_u)
print(wellenlänge)
print(anzahl_weg)
l.Latexdocument('abstands_messung.tex').tabular(
[weg * 1e3, anzahl_weg, wellenlänge * 1000],
'{Weg in $\si{\meter}$} &{Anzahl} & {Wellenlänge in $\si{\\nano\meter}$}',
[2, 0, 9],
caption='Messergebnisse bei der Abstandsmessung',
label='tab: messwerte_abstand')
##Brechungsindex_luft
druck_luft, anzahl_luft = np.genfromtxt('anzahl_luft.txt', unpack=True)
druck_kohlenstoff, anzahl_kohlenstoff = np.genfromtxt('anzahl_kohlenstoff.txt',
unpack=True)
def delta_brechungsindex(anzahl, wellenlaenge):
return (anzahl * wellenlaenge) / (2 * 0.05)
def brechungsindex(deltadruck, deltabrechung):
def absorb_gold(a, b, Z, winkel, imp, x_p, x_m, y_p, y_m, name):
###Peak detect
winkel_l2 = winkel[17]
winkel_l3 = winkel[39]
maxi_l2 = winkel[17]
mini_l2 = winkel[12]
maxi_l3 = winkel[39]
mini_l3 = winkel[33]
kante_l2 = mini_l2 + 0.5 * (maxi_l2 - mini_l2)
energie_l2_neu = brag_ener(kante_l2, 1) * 1e-3
kante_l3 = mini_l3 + 0.5 * (maxi_l3 - mini_l3)
energie_l3_neu = brag_ener(kante_l3, 1) * 1e-3
energie_l2 = brag_ener(winkel_l2, 1) * 1e-3
energie_l3 = brag_ener(winkel_l3, 1) * 1e-3
delta_e = (energie_l2 - energie_l3)
abschirm_kosnt = abschirm(Z, delta_e * 1e3)
abschirm_kosnt_neu = abschirm(Z, (energie_l2_neu - energie_l3_neu) * 1e3)
print('Betrachte: ', name)
print('Winkel L2 Kante,max / min', kante_l2, mini_l2)
print('Winkel L3 Kante, max / min', kante_l3, mini_l3)
print('Energie L2 Kante', energie_l2, energie_l2_neu)
print('Energie L3 kante', energie_l3, energie_l3_neu)
print('Abschirm Konstante', abschirm_kosnt, abschirm_kosnt_neu)
print('\n\n\n')
plt.clf()
plt.plot(winkel[:-1], imp[:-1], 'rx', label=r'$Intensität$')
plt.axvline(winkel_l3,
ls='--',
color='b',
label=r'$L_3 \, \theta_{\mathrm{max}}$')
plt.axvline(mini_l3,
ls='--',
color='b',
label=r'$L_3 \, \theta_{\mathrm{min}}$')
plt.axvline(winkel_l2,
ls='--',
color='g',
label=r'$L_2 \, \theta_{\mathrm{max}}$')
plt.axvline(mini_l2,
ls='--',
color='y',
label=r'$L_2 \, \theta_{\mathrm{min}}$')
plt.xlabel(r'$\theta \, \mathrm{in} \, \mathrm{deg}$')
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$')
plt.grid()
plt.xlim(winkel[0] - x_m, winkel[-2] + x_p)
plt.ylim(min(imp[:-1]) - y_m, max(imp[:-1]) + y_p)
plt.legend(loc='best', )
plt.savefig(name + '.pdf')
l.Latexdocument(name + '.tex').tabular(
[
winkel[:len(winkel) // 2], imp[:len(winkel) // 2],
winkel[len(winkel) // 2:], imp[len(winkel) // 2:]
],
'{$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$} & {$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$}',
[2, 0, 2, 0],
caption=
'Messwerte bei der Untersuchung des Absorptionsspektrums von $\ce{Au}$..',
label=name)
def peak(int_1, int_2, winkel, imp, x_p, x_m, y_p, y_m, name):
dic = {}
###Peak detect
max_1 = max(imp[int_1[0]:int_1[1]])
winkel_1 = winkel[np.where(imp == max_1)]
max_2 = max(imp[int_2[0]:int_2[1]])
winkel_2 = winkel[np.where(imp == max_2)]
plt.clf()
plt.plot(winkel, imp, 'rx', label=r'$Intensität$')
plt.axvline(winkel_2, ls='--', color='b', label=r'$K_{\alpha}$')
plt.axvline(winkel_1, ls='--', color='g', label=r'$K_{\beta}$')
plt.grid()
plt.xlabel(r'$\theta \, \mathrm{in} \, \mathrm{deg}$')
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$')
plt.xlim(winkel[0] - x_m, winkel[-2] + x_p)
plt.ylim(min(imp) - y_m, max(imp) + y_p)
plt.legend(loc='best')
plt.savefig(name + '.pdf')
print(len(winkel) // 3)
l.Latexdocument(name + '.tex').tabular(
[
winkel[0:len(winkel) // 3], imp[0:len(winkel) // 3],
winkel[len(winkel) // 3:len(winkel) // 3 * 2],
imp[len(winkel) // 3:len(winkel) // 3 * 2],
winkel[len(winkel) // 3 * 2:], imp[len(winkel) // 3 * 2:]
],
'{$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$} & {$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$} &{$\\theta \, / \, \si{\\degree}$} & {$I \, / \, \mathrm{Imp}/\mathrm{s}$}',
[2, 0, 2, 0, 2, 0],
caption=
'Messwerte bei der Untersuchung des Emmissionspektrums von $\ce{Cu}$.',
label='emi_cu')
###grenzwinkel
lam_1 = brag_well(winkel_1, 1)
lam_2 = brag_well(winkel_2, 1)
dic['Wellenlänge'] = lam_1
e_1 = brag_ener(winkel_1, 1)
e_2 = brag_ener(winkel_2, 1)
dic['Energie_k_beta'] = e_1
dic['Energie_k_alpha'] = e_2
sigma_1 = absorbkoe(e_1, 29)
sigma_2 = absorbkoe(4 * (-e_2 + e_1), 29)
print('Betrachte: ', name)
print('Energie k_beta', e_1)
print('Energie k_alpha', e_2)
print('Sigma 1', sigma_1)
print('Sigma 2', sigma_2)
print('Maximale Energie', brag_ener(winkel[0], 1))
print('\n\n\n')
## Bestimmung der Halbwertsbreite
#K_alpha peak, Winkel 1
def g(m, x, b):
return m * x + b
imp_winkel1_partner = imp[np.where(imp == max_1)[0][0] - 1]
winkel_1_fit_partner = winkel[np.where(imp == max_1)[0][0] - 1]
parms_winkel1, cov_winkel1 = curve_fit(
g, [winkel_1_fit_partner, winkel_1[0]],
[imp_winkel1_partner, imp[np.where(imp == max_1)][0]])
error_winkel1 = np.sqrt(np.diag(cov_winkel1))
m_uwinkel1 = ufloat(parms_winkel1[0], error_winkel1[0])
b_uwinkel1 = ufloat(parms_winkel1[1], error_winkel1[1])
breite_winkel1 = 2 * (winkel_1 - (max_1 * 0.5 - b_uwinkel1) / m_uwinkel1)
delta_energie_1 = brag_ener(noms(
(max_1 * 0.5 - b_uwinkel1) / m_uwinkel1), 1) - brag_ener(
noms((max_1 * 0.5 - b_uwinkel1) / m_uwinkel1 + breite_winkel1), 1)
print('K_beta fit Steigung', m_uwinkel1)
print('k_beta fit y_achsenabschnitt', b_uwinkel1)
print('ort des Maximums', winkel_1)
print('Höhe des Maximums', max_1)
print('Partner Ort', winkel_1_fit_partner)
print('partner Höhe', imp_winkel1_partner)
print('Ort der Halben beta', (max_1 * 0.5 - b_uwinkel1) / m_uwinkel1)
print('k_beta Breite 1', breite_winkel1)
print('k_beta Breite 1 in ev', delta_energie_1)
print('\n\n\n')
###k_alpha peak
imp_winkel2_partner = imp[np.where(imp == max_2)[0][0] - 1]
winkel_2_fit_partner = winkel[np.where(imp == max_2)[0][0] - 1]
parms_winkel2, cov_winkel2 = curve_fit(
g, [winkel_2_fit_partner, winkel_2[0]],
[imp_winkel2_partner, imp[np.where(imp == max_2)][0]])
error_winkel2 = np.sqrt(np.diag(cov_winkel2))
m_uwinkel2 = ufloat(parms_winkel2[0], error_winkel2[0])
b_uwinkel2 = ufloat(parms_winkel2[1], error_winkel2[1])
breite_winkel2 = 2 * (winkel_2 - (max_2 * 0.5 - b_uwinkel2) / m_uwinkel2)
delta_energie_2 = brag_ener(
noms((max_2 * 0.5 - b_uwinkel2) / m_uwinkel2 + breite_winkel2),
1) - brag_ener(noms((max_2 * 0.5 - b_uwinkel2) / m_uwinkel2), 1)
print(brag_ener(noms(breite_winkel2), 1))
print('K_alpha fit Steigung', m_uwinkel2)
print('k_alpha fit y_achsenabschnitt', b_uwinkel2)
print('ort des Maximums', winkel_2)
print('Höhe des Maximums', max_2)
print('Partner Ort', winkel_2_fit_partner)
print('partner Höhe', imp_winkel2_partner)
print('Ort der Halben alpha', (max_2 * 0.5 - b_uwinkel2) / m_uwinkel2)
print('k_alpha Breite 2', breite_winkel2)
print('k_alpha Breite 2 in ev', delta_energie_2)
print('\n\n\n')
## Plots für die Halbwertsbrete
lauf1 = np.linspace(19, 22, 1000)
lauf2 = np.linspace(21, 23, 1000)
plt.clf()
plt.plot(winkel, imp, 'rx', label=r'$Intensität$')
plt.plot(lauf1,
g(parms_winkel1[0], lauf1, parms_winkel1[1]),
'c-',
label=r'$Ausgleichgerade K_{\beta}$')
plt.plot(lauf2,
g(parms_winkel2[0], lauf2, parms_winkel2[1]),
'y-',
label=r'$Ausgleichgerade K_{\alpha}$')
plt.axvline(winkel_2, ls='--', color='b', label=r'$K_{\alpha}$')
plt.axvline(winkel_1, ls='--', color='g', label=r'$K_{\beta}$')
plt.grid()
plt.xlabel(r'$\theta \, \mathrm{in} \, \mathrm{deg}$')
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$')
plt.xlim(17.5, 23.5)
plt.ylim(0, 4400)
plt.legend(loc='best')
plt.savefig(name + '_zoom.pdf')
##Auswertung der maximalen Energie
plt.clf()
plt.plot(winkel[0:10], imp[0:10], 'rx', label=r'$Intensität$')
plt.grid()
plt.xlabel(r'$\theta \, \mathrm{in} \, \mathrm{deg}$')
plt.ylabel(r'$I \, \mathrm{in} \, \mathrm{Imp}/\mathrm{s}$')
plt.axvline(winkel[3],
ls='--',
color='b',
label=r'$\theta_{\mathrm{min,u}} \, untere \, Schranke}$')
plt.axvline(winkel[7],
ls='--',
color='g',
label=r'$\theta_{\mathrm{min,o}} \,obere\, Schranke}$')
plt.legend(loc='best')
plt.xlim(3.8, 6)
plt.ylim(20, 80)
#plt.show()
plt.savefig(name + '_maximale_energies.pdf')
winkel_min = winkel[3] + 0.5 * (winkel[7] - winkel[3])
print('Minimaler Winkel', winkel_min)
print('Maximale Energie', brag_ener(winkel_min, 1) * 1e-3)
print('Wellenlänge', brag_well(winkel_min, 1))
print('\n\n\n')
energie_k.append(
1e3 *
absorb(15, 21, 35, 0.5 * winkel_brom, int_brom, 0.5, 0.5, 1, 1, 'brom'))
energie_k.append(1e3 * absorb(14, 20, 38, 0.5 * winkel_stom, int_strom, 0.25,
0.25, 10, 1, 'strom'))
energie_k.append(1e3 * absorb_zink(14, 20, 8, 25, 30, 0.5 * winkel_zink,
int_zink, 0.25, 0.25, 20, 10, 'zink'))
absorb_gold(14, 20, 79, 0.5 * winkel_gold, int_gold, 0.25, 0.25, 10, 1, 'gold')
### Bestimmung der Rydbergenergie
#Z=[40-2.88,32-3.09,35-2.98,38-2.98,30-3.37]
Z = [40, 32, 35, 38, 30]
Element = ['$\ce{Zr}$', '$\ce{Ge}$', '$\ce{Br}$', '$\ce{Sr}$', '$\ce{Zn}$']
l.Latexdocument('ryd.tex').tabular(
[Z, np.sqrt(energie_k)],
'{Element} & {Z} & {$E_{\mathrm{K}}$}', [0, 1],
caption='Experimentell bestimmten Energie $E_{\mathrm{K}}$',
label='ener_ryd')
def g(m, x, b):
return m * x + b
parms, cov = curve_fit(g, Z, np.sqrt(energie_k))
error = np.sqrt(np.diag(cov))
m_u = ufloat(parms[0], error[0])
b_u = ufloat(parms[1], error[1])
print('Regressionsrechnugng E_k und Z')
print('Steigung/Rydberggenerie', m_u)
print('Steigung/Rydberggenerie', m_u**2)
import numpy as np
import uncertainties.unumpy as unp
from uncertainties.unumpy import nominal_values as noms, std_devs as stds
from uncertainties import ufloat
import math
from scipy.optimize import curve_fit
import scipy.constants
import matplotlib.pyplot as plt
from pint import UnitRegistry
import random
import latex as l
u = UnitRegistry()
Q_ = u.Quantity
r = l.Latexdocument('results.tex')
e = Q_(scipy.constants.e, 'coulomb')
###########################################
#DATEN EINLESEN
N_raw = np.genfromtxt('counts_plateau.txt', unpack=True)
delta_t = 60
errors_raw = np.sqrt(N_raw)
N = unp.uarray(N_raw, errors_raw) / delta_t
U = Q_(np.linspace(310, 700, 40), 'volt')
I = np.genfromtxt('strom.txt', unpack=True)
#Ladungsmenge
delta_Q = Q_(I / N, 'microampere * second').to('gigacoulomb') / e
l.Latexdocument('tabs/zählrate_strom_ladung.tex').tabular(
[
U.magnitude, N_raw,
np.sqrt(N_raw),
print('Schwingungsfrequenz Theorie v_-', v_mint)
print('\n')
print('Schwingungsfrequenz Theorie v_+', v_plut)
print('\n')
verhaeltnis = (1 / n)
#n_theo=(v_plut+v_mint)/(2*(v_mint-v_plut))
n_theo = (2 * (v_mint - v_plut)) / (v_plut + v_mint)
print('Theoretisch Verhältnis', n_theo)
n_verhl = ((verhaeltnis / (n_theo)) - 1) * 100
latex.Latexdocument('teila_ck_n_mit_theo.tex').tabular(
[c_k.magnitude, n, verhaeltnis, n_theo, n_verhl],
r'{$C\ua{k}$ in $\si{\nano\farad}$} & {Anzahl Schwingungsmaxima} & {Verhäl. $n$ in \%} & { Verhäl. $n\ua{theo}$ in \%} & {rel. Abw. $\frac{n}{n\ua{theo}}$ in \%}',
[1, 1, 2, 2, 1],
caption=
r'Anzahl der Schwingungsmaxima bei verschiedenenen Kapazitäten $C_k$',
label='teila_n_ck')
verhaeltnis = ((1 / n) - 1) * 100
#for n in range(len(v_mint)):
# a[n]=v_plut.magnitude.noms
# b[n]=v_plu.magnitude.stds
#v_plut_list=unp.uarray(a,b)
#print(v_plut_list)
##Aufgabenteil b
c_k_1, v_plug, v_ming = np.genfromtxt('teilaufgabe_b_frequenzen.txt',
unpack=True)
v_ming = Q_(unp.uarray(v_ming, 1), 'kilohertz')
C = ufloat(2.098e-9, 0.006e-9)
#Messwerte einlesen
frequenz1, U_G_1, U_C_1, a1, b1 = np.genfromtxt(
'frequenzabhängigkeit_amplitude_phase.txt', unpack=True)
frequenz2, U_G_2, U_C_2, a2, b2 = np.genfromtxt('frequenz_2.txt', unpack=True)
frequenz = np.concatenate((frequenz1, frequenz2), axis=0)
U_G = np.concatenate((U_G_1, U_G_2), axis=0)
U_C = np.concatenate((U_C_1, U_C_2), axis=0)
a = np.concatenate((a1, a2), axis=0)
b = np.concatenate((b1, b2), axis=0)
phase = a / b * 2 * np.pi
latex.Latexdocument('frequenzabhängigkeit.tex').tabular(
[frequenz, U_G, U_C, a, b, phase],
'{$\\nu$ / \si{\hertz}} & {$U$ / $\si{\\volt}$} & {$U_C$ / $\si{\\volt}$} & {$a$ / $\si{\micro\second}$} & {$b$ / $\si{\micro\second}$} & {$\phi$ / rad}',
[0, 2, 2, 2, 2, 2],
caption=
'Messwerte der Zeitparameter a und b, Kondensator- und Generatorspannung, sowie die errechnete Phasendifferenz in Abhängigkeit von der Frequenz $\\nu$.',
label='tab: frequenzabhängigkeit')
amplitude = np.genfromtxt('amplitude_schwingfall.txt', unpack=True)
time = np.linspace(0, 12, 13) * 30e-6
latex.Latexdocument('amplitude.tex').tabular(
[time * 100000, amplitude],
'{$t$ / $10^{-5}\si{\second}$} & {$A$ / $\si{\\volt}$}', [1, 2],
caption='Zeitlicher Verlauf der Amplitude des gedämpften Schwingkreises.',
label='tab: amplitude')
def lin_function(t, m, b):
return m * t + b
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
from pint import UnitRegistry
import scipy.constants as const
import latex as l
r = l.Latexdocument('plots.tex')
u = UnitRegistry()
Q_ = u.Quantity
import pandas as pd
from pandas import Series, DataFrame
from scipy.signal import find_peaks
import os
def abs_path(filename):
return os.path.join(os.path.dirname(__file__), filename)
# Import measurment datas
channel_content_sb_ba = np.genfromtxt(
'./2018-10-29_becker_grisard/sb_or_ba.txt', unpack=True)
# --- Import params to transform binnumber to energy ---#
params, errors = np.genfromtxt('./umrechnungen_bins_to_energy.txt',
unpack=True)
return np.sqrt( 1/(L.magnitude * C.magnitude) * (1 - 0.25 * L.magnitude * C.magnitude * (2*np.pi*nus)) )
def impedanz_plot(omega):
return np.sqrt(L.magnitude / C.magnitude) * 1/np.sqrt( 1 - 0.25 * omega**2 * L.magnitude * C.magnitude )
def impedanz(omega):
return np.sqrt(L / C) * 1/np.sqrt( 1 - 0.25 * omega**2 * L * C )
#variabel_1,variabel_2=np.genfromtxt('name.txt',unpack=True)
#Einlesen der Messwerte
eigenfrequenzen_a_LC = np.genfromtxt('eigenfrequenzen_a_LC.txt', unpack=True)
range_lin = np.linspace(1, len(eigenfrequenzen_a_LC), 12)
Phasenverschiebung_pro_glied_LC = np.pi * range_lin / 16
latex.Latexdocument('tabs/eigenfrequenzen_dispersion_LC.tex').tabular([Phasenverschiebung_pro_glied_LC, eigenfrequenzen_a_LC],
'{$\\theta$} & {$\\nu$ in $\si{\hertz}$}', [1, 0],
caption = 'LC-Kette, Gemessene Frequenzen mit zugeordnetem Phasenversatz pro Glied', label = 'tab: dispersion_LC')
eigenfrequenzen_a_LC1C2 = np.genfromtxt('eigenfrequenzen_a_LC1C2.txt', unpack=True)
range_lin = np.linspace(1, len(eigenfrequenzen_a_LC1C2), len(eigenfrequenzen_a_LC1C2))
Phasenverschiebung_pro_glied_LC1C2 = np.pi * range_lin / 16
for i in range(0, len(Phasenverschiebung_pro_glied_LC1C2)):
if (Phasenverschiebung_pro_glied_LC1C2[i] > np.pi/2):
Phasenverschiebung_pro_glied_LC1C2[i] -= 2*(Phasenverschiebung_pro_glied_LC1C2[i] - np.pi/2)
latex.Latexdocument('tabs/eigenfrequenzen_dispersion_LC1C2.tex').tabular([Phasenverschiebung_pro_glied_LC1C2, eigenfrequenzen_a_LC1C2],
'{$\\theta$} & {$\\nu$ in $\si{\hertz}$}', [1, 0],
caption = '$LC_1C_2$-Kette, Gemessene Frequenzen mit zugeordnetem Phasenversatz pro Glied', label = 'tab: dispersion_LC1C2')
frequenzen_sweep_LC = np.genfromtxt('frequenz_sweep_LC.txt', unpack = True)
x_range_LC = ((np.linspace(1, len(frequenzen_sweep_LC), len(frequenzen_sweep_LC))-1) * 4)[::-1]
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
import math
import datetime
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
from pint import UnitRegistry
import latex as l
r = l.Latexdocument('plots.tex')
u = UnitRegistry()
Q_ = u.Quantity
import pandas as pd
from pandas import Series, DataFrame
from scipy.signal import find_peaks
import os
def abs_path(filename):
return os.path.join(os.path.dirname(__file__), filename)
# ########################################################################### #
# ###################### --- Bestimmung der Peaks --- ####################### #
# ########################################################################### #
channel_content_eu = np.genfromtxt('./2018-10-29_becker_grisard/europium.txt',
unpack=True)
nullrate = 167
nullrate *= (240) / (900)
##Isotop mit einem eifachen Zerfall
zeit, anzahl = np.genfromtxt('zaehlrate_indium.txt', unpack=True)
zeit *= 240
anzahl -= nullrate
anzahl_fehler = np.sqrt(anzahl)
anzahlu = unp.uarray(anzahl, anzahl_fehler)
fehlelog_indium = fehler_log(anzahl)
l.Latexdocument('messwerte_indium.tex').tabular(
[zeit, anzahl, anzahl_fehler, fehlelog_indium[1], fehlelog_indium[0]],
'Jo', [0, 0, 0, 2, 2],
caption='Gemessene Anzahl an Zerfällen bei Indium',
label='tab: indium_messwerte')
#latex.Latexdocument('messwerte_indium.tex').tabular([zeit, anzahl, anzhal_fehler, fehler_log[1], fehler_log[0] ],
#'{$t$ in $\si{\secod}$} & {Anzahl $N$} & {$\sigma\ua{N}$} & {$\ln{N+\sigma\ua{N}}-\ln{N}$} & {$\ln{N-\sigma\ua{N}}-\ln{N}$}', [1, 1, 1,1 ,1 ] ,
#caption = 'Gemessene Anzahl an Zerfällen bei Indium', label = 'tab: indium_messwerte')
def g(x, m, b):
return m * x + b
params_indium, cov_indium = curve_fit(g, zeit, np.log(anzahl))
indium_errors = np.sqrt(np.diag(cov_indium))
indium_u = unp.uarray(params_indium, indium_errors)
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
import math
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
from pint import UnitRegistry
import latex as l
r = l.Latexdocument('results.tex')
from scipy.constants import *
##r = l.Latexdocument('results.tex')
#u = UnitRegistry()
#Q_ = u.Quantity
#import pandas as pd
#from pandas import Series, DataFrame
##series = pd.Series(data, index=index)
## d = pd.DataFrame({'colomn': series})
#
#a = ufloat(1, 0.1)
#r.app('I', Q_(a, 'ampere'))
#r.makeresults()
##r.makeresults()
def g(m, x, b):
return m * x + b
import numpy as np
import uncertainties.unumpy as unp
from uncertainties import ufloat
from uncertainties.unumpy import nominal_values as noms
from uncertainties.unumpy import std_devs as stds
from uncertainties import correlated_values
import math
from scipy.optimize import curve_fit
from pint import UnitRegistry
import latex as l
r = l.Latexdocument('results.tex')
u = UnitRegistry()
Q_ = u.Quantity
import os
def abs_path(filename):
return os.path.join(os.path.dirname(__file__), filename)
import matplotlib as mlp
mlp.use('pgf')
import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.family'] = 'serif'
rcParams['font.serif'] = '[lmroman10-regular]:+tlig;'
rcParams['text.usetex'] = True
rcParams['pgf.texsystem'] = 'lualatex'
rcParams['font.size'] = 10
rcParams['mathtext.fontset'] = 'custom'
