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