def main():
squid = loadCSVToList('../calc/bfields_leiterschleife_fit.txt')
theo = loadCSVToList('../calc/bfields_leiterschleife_theo.txt')
resistors = loadCSVToList('../data/resistors.txt')
x = [u / r for r, u in resistors]
sx = [0.01 / r for r, u in resistors]
ysquid, sysquid = zip(*squid)
ytheo, sytheo = zip(*theo)
c = TCanvas('c', '', 1280, 720)
theoData = DataErrors.fromLists(x, ytheo, sx, sytheo)
gTheo = theoData.makeGraph('gTheo', 'Strom I / A', 'Magnetfeld B_{z} / T')
gTheo.SetMarkerColor(2)
gTheo.SetLineColor(2)
gTheo.Draw('AP')
squidData = DataErrors.fromLists(x, ysquid, sx, sysquid)
gSquid = squidData.makeGraph('gSquid', 'Strom I / A', 'Magnetfeld B_{z} / T')
gSquid.Draw('P')
l = TLegend(0.15, 0.7, 0.5, 0.85)
l.SetTextSize(0.03)
l.AddEntry(gSquid, 'gemessene Magnetfeldst#ddot{a}rke B_{z}', 'p')
l.AddEntry(gTheo, 'theoreitsche Magnetfeldst#ddot{a}rke B_{z}', 'p')
l.Draw()
c.Update()
c.Print('../img/compare.pdf', 'pdf')
c.SetLogy()
c.SetLogx()
c.Update()
c.Print('../img/compare_loglog.pdf', 'pdf')
def main():
effmatrix = loadCSVToList('../calc/efficencies.txt')
seffmatrix = loadCSVToList('../calc/efficencies_error.txt')
t1 = time.time()
#generate matrices
ms = []
for i in range(100000):
m = generateErrorMatrix(effmatrix, seffmatrix)
ms.append(inv(m))
#group values
sigmas = [[[] for i in range(4)] for j in range(4)] # empty 4x4 matrix
for i in range(4):
for j in range(4):
entries = []
for m in ms:
entries.append(m[i][j])
sigmas[i][j] = std(entries, ddof=1)
t2 = time.time()
print('%.3f' % (t2 - t1))
print(matrix(sigmas))
with TxtFile('../calc/invEfficencies_error.txt', 'w') as f:
f.write2DArrayToFile(sigmas, ['%.7f'] * 4)
def main():
effmatrix = loadCSVToList('../calc/efficencies.txt')
seffmatrix = loadCSVToList('../calc/efficencies_error.txt')
t1 = time.time()
#generate matrices
ms = []
for i in range(100000):
m = generateErrorMatrix(effmatrix, seffmatrix)
ms.append(inv(m))
#group values
sigmas = [[[] for i in range(4)] for j in range(4)] # empty 4x4 matrix
for i in range(4):
for j in range(4):
entries = []
for m in ms:
entries.append(m[i][j])
sigmas[i][j] = std(entries, ddof=1)
t2 = time.time()
print('%.3f' % (t2 - t1))
print(matrix(sigmas))
with TxtFile('../calc/invEfficencies_error.txt', 'w') as f:
f.write2DArrayToFile(sigmas, ['%.7f'] * 4)
def makeBfields_theo():
bfields = loadCSVToList('../calc/bfields_leiterschleife_theo.txt')
bfields = [(B * 1e9, sB * 1e9) for B, sB in bfields]
resistors = loadCSVToList('../data/resistors.txt')
I = [u / r * 1000 for r, u in resistors]
sI = [0.01 / r * 1000 for r, u in resistors]
data = zip(I, sI, *zip(*bfields))
with TxtFile('../src/bfields_theo.tex', 'w') as f:
f.write2DArrayToLatexTable(data, ['$I$ / mA', '$s_I$ / mA', '$B_z$ / nT', '$s_{B_z}$ / nT'],
['%.4f', '%.4f', '%.3f', '%.3f'],
'Theoretische Magnetfeldst\"arke $B_z$ in Abh\"angigkeit des Stroms $I$, der durch die Leiterschleife flie\"st.',
'tab:B:theo')
def calibrateNDFilters():
errorp = 0.01 # percentage error
offset = 70
data = loadCSVToList('../data/part5/04.10/filters.txt')
ref = data[0][2] + offset
sref = sqrt((data[0][2] * errorp) ** 2 + (offset * errorp) ** 2)
newdata = []
filters = dict()
for d in data:
int = (d[2] + offset) / ref
if int == 1:
sint = 0
else:
sint = int * sqrt((sqrt((d[2] * errorp) ** 2 + (offset * errorp) ** 2) / (d[2] + offset)) ** 2 + (sref / ref) ** 2)
newdata.append(d + [int * 100, sint * 100])
filters[d[0]] = (int, sint)
with TxtFile('../src/tab_part5_NDFilters.tex', 'w') as f:
f.write2DArrayToLatexTable(newdata,
["Stärke des Filters", r"$I_\text{nominell}$ / \%", r"$U_\text{ph}$ / mV", r"$I_\text{mess}$ / \%", r"$s_{I_\text{mess}}$ / \%"],
['%.1f', '%.3f', '%d', '%.2f', '%.2f'],
r'Kalibrierung der Neutraldichtefilter: Nominelle Transmission $I_{\text{nominell}}$, gemessene Spannung an der Photodiode $U_{\text{ph}}$ und daraus berechnete Transmission $I_{\text{mess}}$. ',
'tab:deh:dnfilter')
return filters
def loadCrossSection(ctype):
datalist = loadCSVToList('../calc/crosssections_%s.txt' % ctype)
xlist = list(zip(*datalist))[0]
sxlist = [0] * len(xlist)
ylist = list(zip(*datalist))[1]
sylist = list(zip(*datalist))[2]
return DataErrors.fromLists(xlist, ylist, sxlist, sylist)
def makeTempTable(): # table with calculated pressures
data = loadCSVToList('../calc/temp_pressure.txt')
data.sort(key=lambda x: x[0], reverse=True)
with TxtFile('../src/temp_pressure.tex', 'w') as f:
f.write2DArrayToLatexTable(data, ['$T$ / ${}^{\\circ}$C', '$p$ / mPa', '$s_p$ / mPa'],
['%d', '%.0f', '%.0f'], 'Dampfdruck von Quecksilber bei verschiedenen Temperaturen.',
'tab:pressure')
def loadCrossSection(ctype):
datalist = loadCSVToList('../calc/crosssections_%s.txt' % ctype)
xlist = list(zip(*datalist))[0]
sxlist = [0] * len(xlist)
ylist = list(zip(*datalist))[1]
sylist = list(zip(*datalist))[2]
return DataErrors.fromLists(xlist, ylist, sxlist, sylist)
def getDistances():
# load data
f = lambda x: x[0]
distances = loadCSVToList('../data/part2/length/lengths.txt')
distances = map(f, distances)
sd = 0.05
return map(lambda x: (x, sd), distances)
def main():
data = loadCSVToList('../data/141022/squid_pattern_HM1508-2.csv', ',')
xlist, y1list, y2list, temp = zip(*data)
uSquid = Data.fromLists(xlist, y1list)
uRef = Data.fromLists(xlist, y2list)
uRef.multiplyY(0.1)
c = TCanvas('c', '', 1280, 720)
gSquid = uSquid.makeGraph('gSquid', 'Zeit t / s', 'Spannung U / V')
gSquid.SetMarkerStyle(1)
gRef = uRef.makeGraph('gRef')
gRef.SetMarkerStyle(1)
gRef.SetMarkerColor(2)
gSquid.GetXaxis().SetLimits(0, 0.2)
gSquid.Draw('AP')
gRef.Draw('P')
l = TLegend(0.725, 0.85, 0.99, 0.99)
l.SetTextSize(0.03)
l.AddEntry(gSquid, 'Spannung am SQUID', 'p')
l.AddEntry(gRef, 'Spannung am Funktions-', 'p')
l.AddEntry(0, 'generator (mit Faktor 0.1)', '')
l.Draw()
c.Update()
c.Print('../img/pattern.pdf', 'pdf')
def main():
x, y, sy = zip(*loadCSVToList('../calc/part3/Co-Si_mergedbins.txt'))
data = DataErrors.fromLists(x, y, [0]*len(x), sy)
c = TCanvas('c', '', 1280, 720)
g = data.makeGraph('g', 'Kanal k', 'Counts N')
g.SetMarkerStyle(8)
g.SetMarkerSize(0.5)
g.SetLineColor(15)
g.SetLineWidth(0)
g.Draw('AP')
fit = Fitter('f', '1/(sqrt(2*pi*[2]^2))*gaus(0)')
fit.setParam(0, 'A', 50)
fit.setParam(1, 'x_{c}', 690)
fit.setParam(2, 's', 20)
fit.fit(g, 672, 712)
fit.saveData('../calc/part3/fit_Co-Si_01_mergedbins.txt', 'w')
with TxtFile('../calc/part3/fit_Co-Si_01_mergedbins_raw.txt', 'w') as f:
for key, param in fit.params.iteritems():
f.writeline('\t', *map(str, [param['value'], param['error']]))
l = TLegend(0.7, 0.5, 0.95, 0.85)
l.SetTextSize(0.0225)
l.AddEntry(g, 'Gemittelte Messwerte', 'p')
l.AddEntry(fit.function, 'Fit mit', 'l')
l.AddEntry(0, 'N(k) = #frac{A}{#sqrt{2#pi*#sigma^{2}}} exp(- #frac{1}{2} (#frac{x-x_{c}}{#sigma})^{2})', '')
l.AddEntry(0, '', '')
fit.addParamsToLegend(l, chisquareformat='%.2f')
l.Draw()
c.Update()
c.Print('../img/part3/Co-Si_01_mergedbins.pdf', 'pdf')
def calibrateNDFilters():
errorp = 0.01 # percentage error
offset = 70
data = loadCSVToList('../data/part5/04.10/filters.txt')
ref = data[0][2] + offset
sref = sqrt((data[0][2] * errorp)**2 + (offset * errorp)**2)
newdata = []
filters = dict()
for d in data:
int = (d[2] + offset) / ref
if int == 1:
sint = 0
else:
sint = int * sqrt((sqrt((d[2] * errorp)**2 +
(offset * errorp)**2) /
(d[2] + offset))**2 + (sref / ref)**2)
newdata.append(d + [int * 100, sint * 100])
filters[d[0]] = (int, sint)
with TxtFile('../src/tab_part5_NDFilters.tex', 'w') as f:
f.write2DArrayToLatexTable(
newdata, [
"Stärke des Filters", r"$I_\text{nominell}$ / \%",
r"$U_\text{ph}$ / mV", r"$I_\text{mess}$ / \%",
r"$s_{I_\text{mess}}$ / \%"
], ['%.1f', '%.3f', '%d', '%.2f', '%.2f'],
r'Kalibrierung der Neutraldichtefilter: Nominelle Transmission $I_{\text{nominell}}$, gemessene Spannung an der Photodiode $U_{\text{ph}}$ und daraus berechnete Transmission $I_{\text{mess}}$. ',
'tab:deh:dnfilter')
return filters
def evalSigmaChannelDatas(datas):
x = list(zip(*datas))[0]
sx = list(zip(*datas))[1]
y = list(zip(*datas))[2]
sy = list(zip(*datas))[3]
data = DataErrors.fromLists(x, y, sx, sy)
c = TCanvas('c_sc', '', 1280, 720)
g = data.makeGraph('g_sc', 'channel c', '#sigma(channels)')
g.Draw('AP')
c.Update()
c.Print('../img/energieaufloesung_channels.pdf', 'pdf')
ecallist = loadCSVToList('../calc/ecal_sigmas.txt')
x, sx, y, sy = list(zip(*ecallist))
ecaldata = DataErrors.fromLists(x, y, sx, sy)
g.SetMaximum(50)
g.Draw('AP')
gecal = ecaldata.makeGraph('g_ecal', 'channel c', '#sigma(channels)')
gecal.SetMarkerColor(2)
gecal.SetLineColor(2)
gecal.Draw('P')
l = TLegend(0.15, 0.7, 0.5, 0.85)
l.SetTextSize(0.03)
l.AddEntry(g, 'fitted #sigma of LED-Peaks', 'p')
l.AddEntry(gecal, 'fitted #sigma of energy calibration peaks', 'p')
l.Draw()
c.Update()
c.Print('../img/energieaufloesung_channels+ecal.pdf', 'pdf')
def loadTempDict():
"""load temperature to pressure data (calculated with mathematica)"""
data = loadCSVToList('../calc/temp_pressure.txt')
d = dict()
for T, p, sp in data:
d[T] = (p, sp)
return d
def convertChannelToEnergy(self):
calibration = loadCSVToList('../calc/energyCalibration.txt')
((a, sa), (b, sb), (cov,)) = calibration
for i in range(self.getLength()):
x = self.points[i][0]
t = a + x * b
st = np.sqrt(sa ** 2 + (x * sb) ** 2 + 2 * x * cov)
self.points[i] = (t, self.points[i][1], st, self.points[i][3])
def makeTable():
sigmas = loadCSVToList('../calc/invEfficencies_error.txt')
thead = [r"Schnitt$\backslash$MC-Daten", LATEXE, LATEXM, LATEXT, LATEXQ]
firstrow = [LATEXE, LATEXM, LATEXT, LATEXQ]
with TxtFile('../src/tab_effmat_inv_err.tex', 'w') as f:
f.write2DArrayToLatexTable(list(zip(*([firstrow] + list(zip(*sigmas))))), thead,
['%s'] + ['%.7f']*4,
'Fehler der inversen Effizienzmatrix, berechnet mit einem toy-experiment.',
'tab:inveffmat:err')
def eval(freq):
# load data
data = loadCSVToList('../data/pock_gleich_%dhz.txt' % freq)
sv = 1 # error on single meassurement
# calculate r41
diffs = map(lambda x: (x[0] + x[1], np.sqrt(2) * sv), data)
avg = avgerrors(*zip(*diffs))
return calcr41(*avg)
def main():
data = loadCSVToList('../data/fara_2epsilon.txt')
inner = np.average(data[0])
outer = np.average(data[1])
dif = 180 + outer - inner
error = 2.0 * np.sqrt(2) / np.sqrt(len(data[0]))
with TxtFile('../calc/fara_2epsilon.txt', 'w') as f:
f.writeline('\t', str(dif), str(error))
def makePhiTable(): # table with fitted angles and position angles
data = loadCSVToList('../calc/avgphis.txt')
data.sort(key=lambda x: x[0])
with TxtFile('../src/avgphis.tex', 'w') as f:
f.write2DArrayToLatexTable(data, ['$\\Phi$ / ${}^{\\circ}$', '$\\Phi_\\text{fit}$ / ${}^{\\circ}$',
'$s_{\\Phi_\\text{fit}}$ / ${}^{\\circ}$'],
['%d', '%.2f', '%.2f'],
'Theoretischer und gefitteter Winkel der drei Einstellungen am Aufbau.',
'tab:avgphis')
def main():
snu = ERRORS["nu"] # TODO get error
sB = ERRORS["B"]
sgyrorel = 0
files = ["H", "Glycol", "Teflon"]
for file in files:
datalist = loadCSVToList("../data/03-%s.txt" % file)
if len(datalist) == 1:
B, nu = datalist[0]
gyro, sgyro = calcGyro(nu, snu, B, sB)
if not sgyrorel == 0:
sgyro = gyro * sgyrorel
with TxtFile("../calc/%s.txt" % file, "w") as f:
f.writeline("\t", "gyro", *map(str, (gyro, sgyro)))
f.writeline("\t", "mu", *map(str, calcMu(gyro, sgyro)))
f.writeline("\t", "gI", *map(str, calcNucGFactor(gyro, sgyro)))
else:
x, y = zip(*datalist)
sx = [0] * len(x)
sy = [snu] * len(y)
data = DataErrors.fromLists(x, y, sx, sy)
data.setXErrorAbs(sB)
c = TCanvas("c%s" % file, "", 1280, 720)
g = data.makeGraph("g%s" % file, "Magnetfeld B / mT", "Resonanzfrequenz #nu / MHz")
g.Draw("AP")
fit = Fitter("fit%s" % file, "[0]*x")
fit.setParam(0, "m", 0.002)
fit.fit(g, datalist[0][0] * 0.95, datalist[-1][0] * 1.05)
fit.saveData("../calc/fit-%s.txt" % file, "w")
l = TLegend(0.15, 0.60, 0.475, 0.85)
l.SetTextSize(0.03)
l.AddEntry(g, "Messdaten", "p")
l.AddEntry(fit.function, "Fit mit #nu(B) = m*B", "l")
l.AddEntry(0, "", "")
fit.addParamsToLegend(
l,
[("%.5f", "%.5f"), ("%.2f", "%.2f")],
chisquareformat="%.2f",
advancedchi=True,
units=["MHz / mT", "MHz"],
)
l.Draw()
gyro = 2 * np.pi * fit.params[0]["value"] * 1e9 # in Hz / T
sgyro = 2 * np.pi * fit.params[0]["error"] * 1e9 # in Hz / T
sgyrorel = sgyro / gyro
with TxtFile("../calc/%s.txt" % file, "w") as f:
f.writeline("\t", "gyro", *map(str, (gyro, sgyro)))
f.writeline("\t", "sgyrorel", str(sgyrorel))
f.writeline("\t", "mu", *map(str, calcMu(gyro, sgyro)))
f.writeline("\t", "gI", *map(str, calcNucGFactor(gyro, sgyro)))
c.Update()
c.Print("../img/03-%s.pdf" % file, "pdf")
def makeTauTables(): # table with fitted taus and angles for each position
phis = [0, 45, 90]
for phi in phis:
data = loadCSVToList('../calc/taus_%02d.txt' % phi)
data.sort(key=lambda x: x[0], reverse=True)
with TxtFile('../src/taus_%02d.tex' % phi, 'w') as f:
f.write2DArrayToLatexTable(data, ['$T$ / ${}^{\\circ}$C', '$\\tau$ / ns', '$s_{\\tau}$ / ns',
'$\\Phi$ / ${}^{\\circ}$', '$s_{\\Phi}$ / ${}^{\\circ}$'],
['%d', '%.1f', '%.1f', '%.3f', '%.3f'], 'Fitergebnisse f\"ur $\\Phi=%d^\\circ$.' % phi,
'tab:phi:%0d' % phi)
def makeBfields_fit():
bfields = loadCSVToList('../calc/bfields_leiterschleife_fit.txt')
bfields = [(B * 1e9, sB * 1e9) for B, sB in bfields]
res = [100, 510, 1000, 5100, 10000]
data = zip(res, *zip(*bfields))
with TxtFile('../src/bfields_fit.tex', 'w') as f:
f.write2DArrayToLatexTable(data, ['$R$ / \\textOmega', '$B_z$ / nT', '$s_{B_z}$ / nT'],
['%d', '%.5f', '%.5f'],
'Gemessene Magnetfeldst\"arke $B_z$ in Abh\"angigkeit des Widerstandes $R$ der Leiterschleife.',
'tab:B:fit')
def makeFranzenFits():
MAXFILE = 12
plotParams = loadCSVToList(DIR + 'FitdataRoot.txt')
results = []
for i in range(1, MAXFILE + 1):
results.append(makeFranzenFit(i, plotParams[i - 1]))
mus, sigmas, Bs = list(zip(*results))
# calculate delta T
endtimes = loadCSVToList(DIR + 'endtimes.txt')[0]
darkTimes = []
for (mu, smu), e in zip(*[mus, endtimes]):
dt = e - mu
se = e * 0.01 + 0.1
sdt = sqrt(smu ** 2 + se ** 2)
darkTimes.append((dt, sdt))
makeSigmaFit(darkTimes, sigmas)
makeBFit(darkTimes, Bs)
def makeTable():
sigmas = loadCSVToList('../calc/invEfficencies_error.txt')
thead = [r"Schnitt$\backslash$MC-Daten", LATEXE, LATEXM, LATEXT, LATEXQ]
firstrow = [LATEXE, LATEXM, LATEXT, LATEXQ]
with TxtFile('../src/tab_effmat_inv_err.tex', 'w') as f:
f.write2DArrayToLatexTable(
list(zip(*([firstrow] + list(zip(*sigmas))))), thead,
['%s'] + ['%.7f'] * 4,
'Fehler der inversen Effizienzmatrix, berechnet mit einem toy-experiment.',
'tab:inveffmat:err')
def loadData(self):
datalist = loadCSVToList(self.path)
for row in datalist:
x, N, t, st = row
t /= 1000 # in ms
st /= 1000 # in ms
st *= st_mult
nu = N / t
snu = abs(N * st / t ** 2) # sy = y * (st / t)
self.addPoint(nu, x, snu, X0Data.SX)
def main():
# luminosity
lums = loadCSVToList('../data/daten/lum.txt')
with TxtFile('../src/tab_lums.tex', 'w') as f:
f.write2DArrayToLatexTable(lums,
[r"$\sqrt{s}$ / GeV", r"$L$ / (1/nb)", r"$s_L^\text{stat}$ / (1/nb)",
r"$s_L^\text{sys}$ / (1/nb)", r"$s_L^\text{tot}$ / (1/nb)"],
["%.2f"] + ["%.0f"]*4,
"Zeitlich integrierte Luminosität mit statistischem, systematischem und totalem " +
"Fehler für verschiedene Schwerpunktsenergien.",
"tab:lums")
# beam correction
corr = loadCSVToList('../data/daten/corr.txt')
with TxtFile('../src/tab_beamcorr.tex', 'w') as f:
f.write2DArrayToLatexTable(corr,
[r"$\sqrt{s}$ / GeV", r"$c_\text{beam, \qq}$ / nb", r"$c_\text{beam, \leplep}$ / nb"],
["%.2f", "%.1f", "%.2f"],
r"Strahlungskorrekturen für hadronische und leptonische Zerfälle bei verschiedenen Schwerpunktsenergien.",
"tab:beamcorrs")
def loadData(self):
datalist = loadCSVToList(self.path)
for row in datalist:
T, N, t, st = row
t /= 1000 # in ms
st /= 1000 # in ms
st *= st_mult
nu = N / t
snu = abs(N * st / t ** 2) # sy = y * (st / t)
w = 2 * pi / T
sw = 2 * pi * TData.ST / T ** 2# w * TData.ST / T
self.addPoint(w, nu, sw, snu)
def main():
SU = 0.2 # error U
SI = 0.02 # error I
datalist = loadCSVToList("../data/temps.txt")
listT, listI, listU = zip(*datalist)
listSeries = [TempToSeries(T) for T in listT]
makeGraph(
listI, listU, listSeries, SI, SU, "Stromst#ddot{a}rke I / A", "Spannung U / V", "U-I", True, "I(U) = a + b*U"
)
makeGraph(listI, listT, listSeries, SI, STEMP, "Stromst#ddot{a}rke I / A", "Temperatur T / {}^{#circ} C", "T-I")
makeGraph(listU, listT, listSeries, SU, STEMP, "Spannung U / V", "Temperatur T / {}^{#circ} C", "T-U")
def evalDiode():
datalist = loadCSVToList('../data/part1/Kennlinie.txt')
data = DataErrors()
U0 = datalist[0][1]
sU0 = 0.05 + 0.01 * U0
for I, u in datalist:
U = u - U0
su = 5 + 0.01 * u
sU = sqrt(su**2 + sU0**2)
data.addPoint(I, U, 0.1, sU)
xmin, xmax = 53, 71.5
c = TCanvas('c_diode', '', 1280, 720)
g = data.makeGraph('g_diode', "Laserstrom I_{L} / mA",
"Photodiodenspannung U_{ph} / mV")
g.GetXaxis().SetRangeUser(-5, 90)
g.SetMinimum(-50)
g.SetMaximum(1400)
g.Draw('APX')
# y=0 line
line = TLine(-5, 0, 90, 0)
line.SetLineColor(OPData.CH2ECOLOR)
line.Draw()
data.filterX(xmin, xmax)
g2 = data.makeGraph('g_diode_2', "Laserstrom I_{L} / mA",
"Photodiodenspannung U_{ph} / mV")
g2.SetMarkerColor(OPData.CH1COLOR)
g2.SetLineColor(OPData.CH1COLOR)
fit = Fitter('fit_diode', '[0] * (x-[1])')
fit.function.SetNpx(1000)
fit.setParam(0, 'a', 1)
fit.setParam(1, 'I_{th}', 50)
fit.fit(g2, 40, 77)
fit.saveData('../fit/part1/kennlinie.txt')
l = TLegend(0.15, 0.55, 0.4, 0.85)
l.SetTextSize(0.03)
l.AddEntry(g, 'Laserdiodenkennlinie', 'p')
l.AddEntry(g2, 'Ausschnitt zum Fitten', 'p')
l.AddEntry(fit.function, 'Fit mit U_{ph} = a (I_{ L} - I_{ th} )', 'l')
fit.addParamsToLegend(l, (('%.1f', '%.1f'), ('%.2f', '%.2f')),
chisquareformat='%.2f',
units=['mV/mA', 'mA'])
l.Draw()
g.Draw('P')
g2.Draw('P')
c.Update()
c.Print('../img/part1/diodenkennlinie.pdf', 'pdf')
def evalPart3():
detectors = [('CdTe', 23), ('Si', 100)] # detectors with areas in mm
elements = ['Am', 'Co']
absProbs = []
for det, area in detectors:
# fits
fitresults = []
litvals = [] # literature values for energies of peaks
for elem in elements:
fitresults.append(fitSpectrum(det, elem, getParams(det, elem)))
# add manually peak for Si-Co
if det == 'Si' and elem == 'Co':
fitresults.append([loadCSVToList('../calc/part3/fit_Co-Si_01_mergedbins_raw.txt')])
litvals += getEnergyLitVals(elem)
# make energy gauge and calculate absorption probabilities
peaks = []
sigmas = []
absProbs_det = []
for fit in fitresults:
for peak in fit:
c, sc = peak[-2]
sigmas.append(peak[-1])
peaks.append((c, sc))
absProbs_det.append(calcAbsorpProb(peak, area))
makeEnergyGauge(det, peaks, litvals)
absProbs.append(absProbs_det)
with TxtFile('../calc/part3/AbsProbs_%s.txt' % det, 'w') as f:
for i, absProb in enumerate(absProbs_det):
f.writeline('\t', str(litvals[i]), *map(str, absProb))
with TxtFile('../calc/part3/RER_%s.txt' % det, 'w') as f:
RERs = []
for sigma, peak in zip(sigmas, peaks):
s, ss = sigma
p, sp = peak
RER = 2*np.sqrt(2*np.log(2))*s/ p
sRER = RER * np.sqrt((ss / s) ** 2 + (sp / p) ** 2)
RERs.append(RER)
f.writeline('\t', str(p), str(sp), str(RER), str(sRER))
# calculate absorption rations for peaks
detnames = zip(*detectors)[0]
for i, det1 in enumerate(detnames):
for j, det2 in enumerate(detnames):
if not det1 == det2:
absProbs1 = absProbs[i]
absProbs2 = absProbs[j]
with TxtFile('../calc/part3/AbsRatio_%s_%s.txt' % (det1, det2), 'w') as f:
for k, lists in enumerate(zip(absProbs1, absProbs2)):
f.writeline('\t', str(litvals[k]), *map(str, calcAbsorbProbRatio(*lists)))
def main():
# luminosity
lums = loadCSVToList('../data/daten/lum.txt')
with TxtFile('../src/tab_lums.tex', 'w') as f:
f.write2DArrayToLatexTable(
lums, [
r"$\sqrt{s}$ / GeV", r"$L$ / (1/nb)",
r"$s_L^\text{stat}$ / (1/nb)", r"$s_L^\text{sys}$ / (1/nb)",
r"$s_L^\text{tot}$ / (1/nb)"
], ["%.2f"] + ["%.0f"] * 4,
"Zeitlich integrierte Luminosität mit statistischem, systematischem und totalem "
+ "Fehler für verschiedene Schwerpunktsenergien.", "tab:lums")
# beam correction
corr = loadCSVToList('../data/daten/corr.txt')
with TxtFile('../src/tab_beamcorr.tex', 'w') as f:
f.write2DArrayToLatexTable(
corr, [
r"$\sqrt{s}$ / GeV", r"$c_\text{beam, \qq}$ / nb",
r"$c_\text{beam, \leplep}$ / nb"
], ["%.2f", "%.1f", "%.2f"],
r"Strahlungskorrekturen für hadronische und leptonische Zerfälle bei verschiedenen Schwerpunktsenergien.",
"tab:beamcorrs")
def evalDiode():
datalist = loadCSVToList('../data/part1/Kennlinie.txt')
data = DataErrors()
U0 = datalist[0][1]
sU0 = 0.05 + 0.01 * U0
for I, u in datalist:
U = u - U0
su = 5 + 0.01 * u
sU = sqrt(su ** 2 + sU0 ** 2)
data.addPoint(I, U, 0.1, sU)
xmin, xmax = 53, 71.5
c = TCanvas('c_diode', '', 1280, 720)
g = data.makeGraph('g_diode', "Laserstrom I_{L} / mA", "Photodiodenspannung U_{ph} / mV")
g.GetXaxis().SetRangeUser(-5, 90)
g.SetMinimum(-50)
g.SetMaximum(1400)
g.Draw('APX')
# y=0 line
line = TLine(-5, 0, 90, 0)
line.SetLineColor(OPData.CH2ECOLOR)
line.Draw()
data.filterX(xmin, xmax)
g2 = data.makeGraph('g_diode_2', "Laserstrom I_{L} / mA", "Photodiodenspannung U_{ph} / mV")
g2.SetMarkerColor(OPData.CH1COLOR)
g2.SetLineColor(OPData.CH1COLOR)
fit = Fitter('fit_diode', '[0] * (x-[1])')
fit.function.SetNpx(1000)
fit.setParam(0, 'a', 1)
fit.setParam(1, 'I_{th}', 50)
fit.fit(g2, 40, 77)
fit.saveData('../fit/part1/kennlinie.txt')
l = TLegend(0.15, 0.55, 0.4, 0.85)
l.SetTextSize(0.03)
l.AddEntry(g, 'Laserdiodenkennlinie', 'p')
l.AddEntry(g2, 'Ausschnitt zum Fitten', 'p')
l.AddEntry(fit.function, 'Fit mit U_{ph} = a (I_{ L} - I_{ th} )', 'l')
fit.addParamsToLegend(l, (('%.1f', '%.1f'), ('%.2f', '%.2f')), chisquareformat='%.2f', units=['mV/mA', 'mA'])
l.Draw()
g.Draw('P')
g2.Draw('P')
c.Update()
c.Print('../img/part1/diodenkennlinie.pdf', 'pdf')
def evalUnderground():
# load data
data = SzintData.fromPath('../data/untergrund.TKA')
data.convertToCountrate()
gauge = funcs.loadCSVToList('../calc/energy_gauge_raw.txt')
# make canvas and graph
c = TCanvas('c', '', 1280, 720)
c.SetLogy()
g = data.makeGraph('g', 'Kanalnummer', 'Z#ddot{a}hlrate / (1/s)')
prepareGraph(g)
g.GetXaxis().SetRangeUser(0, 8200)
g.Draw('APX')
c.Update()
c.Print('../img/underground_spectrum.pdf')
# fit
fit = Fitter('f', 'pol1(0) + gaus(2)')
fit.setParam(0, 'a', 2e-3)
fit.setParam(1, 'b', 0)
fit.setParam(2, 'A1', 1e-2)
fit.setParam(3, 'c1', 3500)
fit.setParam(4, 's1', 200)
fit.fit(g, 3250, 4050)
fit.saveData('../calc/underground_peak.txt', 'w')
p, sp = fit.params[3]['value'], fit.params[3]['error']
E, sE = channelToEnergy(p, sp, gauge)
with TxtFile('../calc/underground_peak_energy.txt', 'w') as f:
f.writeline('\t', *map(lambda x: str(x), (p, sp, E, sE)))
l = TLegend(0.6, 0.7, 0.85, 0.85)
l.AddEntry('g', 'Messwerte', 'p')
l.AddEntry(fit.function, 'Fit mit y = a + b*x + gaus(x; A, c, s)', 'l')
l.AddEntry(0, 'Peak: ', '')
l.AddEntry(0, 'c1 = %.2f #pm %.2f' % (p, sp), '')
l.Draw()
c.SetLogy(False)
g.GetXaxis().SetRangeUser(3200, 4100)
g.SetMinimum(0.00025)
g.SetMaximum(0.016)
g.GetYaxis().SetTitleOffset(1.2)
g.Draw('P')
c.Update()
c.Print('../img/underground_peaks.pdf')
def main():
phis = [0, 45, 90]
tempDict = loadTempDict()
avgphis = dict()
taus = []
for phi in phis:
# read data
datalist = loadCSVToList('../calc/taus_%02d.txt' % phi)
datas = {0: [], 1: [], 2: []}
for T, tau, stau, fitphi, sfitphi in datalist:
p, sp = tempDict[T]
datas[TempToSeries(T)].append((p, tau, sp, stau)) # sort in right series list
# make graphs with different series
printGraph(datas, phi)
printGraph(datas, phi, '_total', True)
del datas[0]
taus.append(printGraph(datas, phi, '_day2', True))
del datas[2]
printGraph(datas, phi, '_partial', True)
# calculate average fitted phi
philist = zip(*datalist)[3]
avgphis[phi] = np.average(philist), np.std(zip(*datalist)[3], ddof=1) / np.sqrt(len(philist))
# print out average fittet phis
with TxtFile('../calc/avgphis.txt', 'w') as f:
for phi, avgphi in avgphis.iteritems():
f.writeline('\t', str(phi), *map(str, avgphi))
# print out extraplated taus as LaTeX table
with TxtFile('../src/taus_final.tex', 'w') as f:
f.write2DArrayToLatexTable(zip(phis, *zip(*taus)),
['$\\Phi$ / ${}^{\\circ}$', '$\\tau$ / ns', '$s_{\\tau}$ / ns'],
['%d', '%.1f', '%.1f'],
'Extrapolierte mittlere Lebensdauern bei verschiedenen Winkeleinstellungen.',
'tab:tau:final')
# print out extrapolated taus as csv and calculate weighted average
with TxtFile('../calc/taus_final.txt', 'w') as f:
for tau, error in taus:
f.writeline('\t', str(tau), str(error))
f.writeline('weighted average')
f.writeline('\t', *map(str, avgerrors(*zip(*taus))))
def main():
R = (3.2 + 4.4) / 4 / 1000 # from mm to m
sR = 0.5 / (2 * np.sqrt(2)) / 1000 # from mm to m
z = (29 - 26.5) / 100 # from cm to m
sz = 0.2 * np.sqrt(2) / 100 # from cm m
mu = 4e-7 * np.pi # V*s/(A*m)
sU = 0.01 # in V, 1 digit
data = loadCSVToList('../data/resistors.txt')
bfields = []
for res, U in data: # res in ohm, U in volts
B = (mu * U * (R ** 2)) / (2 * res) / ((R ** 2 + z ** 2) ** (3. / 2))
sB = (R * mu / (2 * res * ((R ** 2 + z ** 2) ** (5. / 2))) *
np.sqrt(R ** 6 * sU ** 2 + 4 * sR ** 2 * U ** 2 * z ** 4 + R ** 2 * z ** 2 *
((-4 * sR ** 2 + 9 * sz ** 2) * U ** 2 + sU ** 2 * z ** 2) + R ** 4 *
(sR ** 2 * U ** 2 + 2 * sU ** 2 * z ** 2)))
bfields.append((B, sB))
with TxtFile('../calc/bfields_leiterschleife_theo.txt', 'w') as f:
for B in bfields:
f.writeline('\t', *map(str, B))
def evalAngleDependency():
datalist = loadCSVToList(DIR + 'Winkelabh.txt')
data = DataErrors()
strel = 0.01
sI = 1
for t2, t1, n, phi in datalist:
f, sf = calcPrecissionFreq(t2, t1, n)
data.addPoint(phi, f, 0.5, sf)
c = TCanvas('c_phi', '', 1280, 720)
g = data.makeGraph('g_phi', 'Rotation des Strahlengangs #varphi / #circ',
'Praezessionsfrequenz f / kHz')
g.GetXaxis().SetRangeUser(-15, 15)
g.SetMinimum(0)
g.Draw('APX')
fit = Fitter('fit_phi', '[0] * abs(sin((x-[1])*pi/180))')
fit.function.SetNpx(1000)
fit.setParam(0, '#beta', 1)
fit.setParam(1, '#phi_{0}', 0)
fit.fit(g, -15, 15)
fit.saveData('../fit/part4/winkel.txt')
g.Draw('P')
l = TLegend(0.7, 0.15, 0.95, 0.5)
l.SetTextSize(0.03)
l.AddEntry(g, 'Praezessionsfrequenz', 'p')
l.AddEntry(fit.function, 'Fit mit f = #beta |sin(#varphi + #varphi_{0})|',
'l')
fit.addParamsToLegend(l, (('%.1f', '%.1f'), ('%.2f', '%.2f')),
chisquareformat='%.2f',
units=['kHz/#muT', '#circ'])
l.Draw()
c.Update()
c.Print('../img/part4/winkel.pdf', 'pdf')
def evalNuclearSpin():
results = []
data = loadCSVToList('../data/part3/part3.txt')
tabledata = []
for d in data[-4:]:
tabledata.append([d[0], d[2]] + d[4:-2])
with TxtFile('../src/tab_part3_data.tex', 'w') as f:
f.write2DArrayToLatexTable(tabledata,
[r"$I_\text{L}$ / mA", r"$\nu$ / kHz",
"$I_1$ / mA", "$s_{I_1}$ / mA", "$I_1'$ / mA", "$s_{I_1'}$ / mA"],
['%.1f', '%.2f', '%d', '%d', '%d', '%d'],
'Messdaten des Doppelresonanzexperiments.', 'tab:part3:data')
for iL, siL, f, sf, i1, si1, i1_, si1_, i4, si4 in data: # I-Laser, frequency, I1, I1', I4 with respective errors
# from mA to A
i1 *= 1e-3
si1 *= 1e-3
i1_ *= 1e-3
si1_ *= 1e-3
i4 *= 1e-3
si4 *= 1e-3
# from kHz to Hz
f *= 1e3
sf *= 1e3
# calc B1, B1'
B1, sB1 = inductorIToB(1, i1, si1)
B1_, sB1_ = inductorIToB(1, i1_, si1_)
# calc B for nuclear spin
B, sB = (B1 + B1_) / 2, sqrt(sB1 ** 2 + sB1_ ** 2) / 2
# calc horizontal B-Field
Bhor, sBhor = abs(B1 - B1_) / 2, sqrt(sB1 ** 2 + sB1_ ** 2) / 2
# calc vertical B-Field
Bvert, sBvert = inductorIToB(4, i4, si4)
# calc nuclear spin
I = mub_JT * B / (h_Js * f) - 0.5
sI = mub_JT * B / (h_Js * f) * sqrt((sB / B) ** 2 + (sf / f) ** 2)
results.append([["I_L/mA", (iL, siL)],
["f/kHz", (f * 1e-3, sf * 1e-3)],
["Bhor/µT", (Bhor * 1e6, sBhor * 1e6)],
["Bver/µT", (Bvert * 1e6, sBvert * 1e6)],
["I\t", (I, sI)]])
# print out results
with TxtFile('../calc/part3.txt', 'w') as f:
for result in results:
for description, values in result:
f.writeline('\t', *([description] + list(map(lambda x: '%.2f' % x, values))))
f.writeline('')
tableresults = []
for result in results:
flattend = [item for sublist in result for item in sublist[1]]
flattend.pop(7)
flattend.pop(6)
flattend.pop(3)
flattend.pop(1)
tableresults.append(flattend)
with TxtFile('../src/tab_part3_results.tex', 'w') as f:
f.write2DArrayToLatexTable(tableresults[-4:],
[r"$I_\text{L}$ / mA", r"$\nu$ / kHz", r"$B_\text{hor}$ / \textmu T", r"$s_{B_\text{hor}}$ / \textmu T",
"$I$", "$s_I$"],
['%.1f', '%.2f', '%.1f', '%.1f', '%.2f', '%.2f'],
r"Berechnete horizontale Komponenten des Erdmagnetfeldes und Kernspin von Rubidium für das " +
r"Doppelresonanzexperiment bei verschiedenen Lasterströmen $I_\text{L}$ und RF-Sender-Frequenzen $\nu$.",
"tab:part3:results")
def evalNuclearSpin():
results = []
data = loadCSVToList('../data/part3/part3.txt')
tabledata = []
for d in data[-4:]:
tabledata.append([d[0], d[2]] + d[4:-2])
with TxtFile('../src/tab_part3_data.tex', 'w') as f:
f.write2DArrayToLatexTable(tabledata, [
r"$I_\text{L}$ / mA", r"$\nu$ / kHz", "$I_1$ / mA",
"$s_{I_1}$ / mA", "$I_1'$ / mA", "$s_{I_1'}$ / mA"
], ['%.1f', '%.2f', '%d', '%d', '%d', '%d'],
'Messdaten des Doppelresonanzexperiments.',
'tab:part3:data')
for iL, siL, f, sf, i1, si1, i1_, si1_, i4, si4 in data: # I-Laser, frequency, I1, I1', I4 with respective errors
# from mA to A
i1 *= 1e-3
si1 *= 1e-3
i1_ *= 1e-3
si1_ *= 1e-3
i4 *= 1e-3
si4 *= 1e-3
# from kHz to Hz
f *= 1e3
sf *= 1e3
# calc B1, B1'
B1, sB1 = inductorIToB(1, i1, si1)
B1_, sB1_ = inductorIToB(1, i1_, si1_)
# calc B for nuclear spin
B, sB = (B1 + B1_) / 2, sqrt(sB1**2 + sB1_**2) / 2
# calc horizontal B-Field
Bhor, sBhor = abs(B1 - B1_) / 2, sqrt(sB1**2 + sB1_**2) / 2
# calc vertical B-Field
Bvert, sBvert = inductorIToB(4, i4, si4)
# calc nuclear spin
I = mub_JT * B / (h_Js * f) - 0.5
sI = mub_JT * B / (h_Js * f) * sqrt((sB / B)**2 + (sf / f)**2)
results.append([["I_L/mA", (iL, siL)],
["f/kHz", (f * 1e-3, sf * 1e-3)],
["Bhor/µT", (Bhor * 1e6, sBhor * 1e6)],
["Bver/µT", (Bvert * 1e6, sBvert * 1e6)],
["I\t", (I, sI)]])
# print out results
with TxtFile('../calc/part3.txt', 'w') as f:
for result in results:
for description, values in result:
f.writeline(
'\t',
*([description] + list(map(lambda x: '%.2f' % x, values))))
f.writeline('')
tableresults = []
for result in results:
flattend = [item for sublist in result for item in sublist[1]]
flattend.pop(7)
flattend.pop(6)
flattend.pop(3)
flattend.pop(1)
tableresults.append(flattend)
with TxtFile('../src/tab_part3_results.tex', 'w') as f:
f.write2DArrayToLatexTable(
tableresults[-4:], [
r"$I_\text{L}$ / mA", r"$\nu$ / kHz",
r"$B_\text{hor}$ / \textmu T",
r"$s_{B_\text{hor}}$ / \textmu T", "$I$", "$s_I$"
], ['%.1f', '%.2f', '%.1f', '%.1f', '%.2f', '%.2f'],
r"Berechnete horizontale Komponenten des Erdmagnetfeldes und Kernspin von Rubidium für das "
+
r"Doppelresonanzexperiment bei verschiedenen Lasterströmen $I_\text{L}$ und RF-Sender-Frequenzen $\nu$.",
"tab:part3:results")
def loadCorrections():
datas = loadCSVToList('../data/daten/corr.txt')
d = dict()
for data in datas:
d[data[0]] = {'qq': data[1], 'll': data[2]}
return d
def loadInvEffMatrix():
m = loadCSVToList('../calc/invEfficencies.txt')
sm = loadCSVToList('../calc/invEfficencies_error.txt')
return m, sm
def loadSTRatios():
datas = loadCSVToList('../calc/s-t-integrals.txt')
d = dict()
for data in datas:
d[data[0]] = data[-2:] # last to elems, value and error
return d
def evalSpinPrecission(name):
datalist = loadCSVToList(DIR + name + '.txt')
data = DataErrors()
sI = 1
for t2, t1, n, I in datalist:
f, sf = calcPrecissionFreq(t2, t1, n)
B, sB = inductorIToB(4, I * 1e-3, sI * 1e-3)
data.addPoint(B * 1e6, f, sB * 1e6, sf)
if len(name) == 4:
xmin, xmax = 0, 50
else:
xmin, xmax = 0, 80
c = TCanvas('c_%s' % name, '', 1280, 720)
g = data.makeGraph('g_%s' % name,
'Zusaetzliches Vertikalfeld B_{S, v} / #muT',
'Praezessionsfrequenz f / kHz')
g.GetXaxis().SetRangeUser(xmin, xmax)
g.Draw('APX')
fit1 = Fitter('fit1_%s' % name, '[0] * abs([1]-x)')
fit1.function.SetNpx(1000)
fit1.setParam(0, '#alpha', 1)
fit1.setParam(1, 'B_{E, v}', 40)
fit1.fit(g, xmin, xmax)
fit1.saveData('../fit/part4/fit1_%s' % name)
fit2 = Fitter('fit1_%s' % name, '[0] * (abs([1]-x) + [2])')
fit2.function.SetNpx(1000)
fit2.function.SetLineColor(3)
fit2.setParam(0, '#alpha', 1)
fit2.setParam(1, 'B_{E, v}', 40)
fit2.setParam(2, 'B_{E,h,s}', 20)
fit2.setParamLimits(2, 0, 100)
fit2.fit(g, xmin, xmax, '+')
fit2.saveData('../fit/part4/fit2_%s' % name)
g.Draw('P')
if len(name) == 4:
l = TLegend(0.6, 0.4, 0.975, 0.95)
else:
l = TLegend(0.325, 0.475, 0.725, 0.99)
l.SetTextSize(0.03)
l.AddEntry(g, 'Praezessionsfrequenzen', 'p')
l.AddEntry(fit1.function,
'Fit mit f_{1}(B_{S, v}) = #alpha |B_{E, v} - B_{S, v}|', 'l')
fit1.addParamsToLegend(l, (('%.2f', '%.2f'), ('%.2f', '%.2f')),
chisquareformat='%.2f',
units=['kHz/#muT', '#muT'])
l.AddEntry(
fit2.function,
'Fit mit f_{2}(B_{S, v}) = #alpha (|B_{E, v} - B_{S, v}| + B_{E,h,s})',
'l')
fit2.addParamsToLegend(l, (('%.2f', '%.2f'), ('%.2f', '%.2f'),
('%.2f', '%.2f')),
chisquareformat='%.2f',
units=['kHz/#muT', '#muT', '#muT'])
l.Draw()
c.Update()
c.Print('../img/part4/%s.pdf' % name, 'pdf')
def loadLums():
datas = loadCSVToList('../data/daten/lum.txt')
d = dict()
for data in datas:
d[data[0]] = data[1:]
return d
