def test_smoothing(calibration):
print("##### SMOOTHING TEST #####")
with LatexTable("out/test_smoothing.tex") as peaktable:
peaktable.header(" ",
r'\multicolumn{3}{|c|}{ohne Gl\"attung}',
r'\multicolumn{3}{|c|}{mit Gl\"attung}',
align=["c"] * 7,
lineafter=0)
peaktable.row("Probe", "Höhe", "Breite", r'$\chi^2/\textrm{ndf}$',
"Höhe", "Breite", r'$\chi^2/\textrm{ndf}$')
peaktable.hline()
for filename, meta in data.items():
peaktable.hline(1)
experiment = Experiment("data/" + filename,
calibration=calibration,
title=meta["title"])
experiment2 = Experiment("data/" + filename,
calibration=calibration,
title=meta["title"])
experiment.subtract_empty("data/G20_Leer.mca", 0.5)
experiment2.subtract_empty("data/G20_Leer.mca", 0.5)
experiment2.smooth(0.1)
lines = []
for i, (mu0, sigma0) in enumerate(
sorted(meta["peaks"], key=lambda peak: peak[0]), 1):
fit = experiment.find_peak(mu0, sigma0, plot=plot)
fit2 = experiment2.find_peak(mu0, sigma0, plot=plot)
peaktable.row(
(meta["title"], len(meta["peaks"])),
_n(fit.mu, precision=3),
_n(fit.sigma, precision=3),
_n(fit.chisqndf),
_n(fit2.mu, precision=3),
_n(fit2.sigma, precision=3),
_n(fit2.chisqndf),
)
def main():
parser = argparse.ArgumentParser(description='get cutflow')
parser.add_argument('-r', dest='regions', help='Region')
parser.add_argument('-s', dest='samples', help='Samples separated with ,')
parser.add_argument('-i', dest='files', help='Files separated with ,')
parser.add_argument('-l', dest='luminosity', help='Luminosity [fb-1]')
parser.add_argument('-p', dest='percentage', action='store_true', help='Show percentage')
parser.add_argument('--latex', action='store_true', default=False, help='use LatexTable instead PrettyTable')
parser.add_argument('--sel', dest='selection', help='Selection')
parser.add_argument('--pre', dest='preselection', action='store_true', help='add preselection cutflow')
if len(sys.argv) < 2:
parser.print_usage()
sys.exit(1)
args = parser.parse_args()
## samples
if args.samples is None and args.files is None:
samples = [
'data',
'photonjet',
'wgamma',
'zllgamma',
'znunugamma',
'ttbar',
'ttbarg',
'wjets',
'zjets',
'diboson',
'efake',
'jfake'
]
if args.regions is None:
args.regions = 'Sel'
do_scale = True
if args.luminosity == "0":
do_scale = False
for region in args.regions.split(','):
#if args.samples is not None:
# files = [ os.path.join(MiniDir, '%s.t146_mini.root' % sample) for sample in args.samples.split(',') ]
#if args.files is not None:
# files = args.files.split(',')
try:
selection = getattr(regions_, region)
except:
selection = args.selection
flows = OrderedDict()
if args.samples is not None:
for sample in args.samples.split(','):
cutflow = get_cutflow(sample, selection=selection, lumi=args.luminosity, preselection=args.preselection, scale=do_scale)
cuts = [ cutflow.GetXaxis().GetBinLabel(b+1) for b in xrange(cutflow.GetNbinsX()) ]
flows[sample] = [ cutflow.GetBinContent(b+1) for b in xrange(cutflow.GetNbinsX()) ]
if args.files is not None:
for fname in args.files.split(','):
cutflow = get_cutflow(fname, selection=selection, preselection=args.preselection, scale=do_scale)
cuts = [ cutflow.GetXaxis().GetBinLabel(b+1) for b in xrange(cutflow.GetNbinsX()) ]
flows[os.path.basename(fname)] = [ cutflow.GetBinContent(b+1) for b in xrange(cutflow.GetNbinsX()) ]
if args.latex:
table = LatexTable()
else:
table = PrettyTable()
table.add_column(region, cuts)
for sample, flow in flows.iteritems():
total = float(flow[0])
if args.percentage:
table.add_column(sample, ['%.2f (%d%%)' % (n, 100*n/total) for n in flow])
else:
table.add_column(sample, ['%.2f' % n for n in flow])
print table
def main():
parser = argparse.ArgumentParser(description='get cutflow')
parser.add_argument('-r', dest='regions', help='Region')
parser.add_argument('-s', dest='samples', help='Samples separated with ,')
parser.add_argument('-i', dest='files', help='Files separated with ,')
parser.add_argument('-l', dest='luminosity', help='Luminosity [fb-1]')
parser.add_argument('-p',
dest='percentage',
action='store_true',
help='Show percentage')
parser.add_argument('-v', dest='version', help='Mini version')
parser.add_argument('--latex',
action='store_true',
default=False,
help='use LatexTable instead PrettyTable')
parser.add_argument('--sel', dest='selection', help='Selection')
parser.add_argument('--pre',
dest='preselection',
action='store_true',
help='add preselection cutflow')
if len(sys.argv) < 2:
parser.print_usage()
sys.exit(1)
args = parser.parse_args()
## samples
if args.samples is None and args.files is None:
sys.exit(1)
if args.regions is None:
args.regions = 'Sel'
do_scale = True
if args.luminosity == "0":
do_scale = False
for region in args.regions.split(','):
try:
selection = getattr(regions_, region)
except:
selection = args.selection
flows = OrderedDict()
if args.samples is not None:
for sample in args.samples.split(','):
cutflow = get_cutflow(sample,
selection=selection,
lumi=args.luminosity,
preselection=args.preselection,
scale=do_scale,
version=args.version)
cuts = [
cutflow.GetXaxis().GetBinLabel(b + 1)
for b in xrange(cutflow.GetNbinsX())
]
flows[sample] = [
cutflow.GetBinContent(b + 1)
for b in xrange(cutflow.GetNbinsX())
]
if args.files is not None:
for fname in args.files.split(','):
cutflow = get_cutflow(fname,
selection=selection,
preselection=args.preselection,
scale=do_scale,
version=args.version)
cuts = [
cutflow.GetXaxis().GetBinLabel(b + 1)
for b in xrange(cutflow.GetNbinsX())
]
flows[os.path.basename(fname)] = [
cutflow.GetBinContent(b + 1)
for b in xrange(cutflow.GetNbinsX())
]
if args.latex:
table = LatexTable()
else:
table = PrettyTable()
table.add_column(region, cuts)
for sample, flow in flows.iteritems():
total = float(flow[0])
if args.percentage:
table.add_column(sample, [
'%.2f (%d%%)' % (n, int(round(100 * (n / total))))
for n in flow
])
else:
table.add_column(sample, ['%.2f' % n for n in flow])
print table
def main():
parser = argparse.ArgumentParser(description='get yields')
parser.add_argument('-r',
dest='regions',
default='',
help='Regions separated with ,')
parser.add_argument('-s', dest='samples', help='Samples separated with ,')
parser.add_argument('-i', dest='files', help='Files separated with ,')
parser.add_argument('-l', dest='lumi', help='Luminosity to scale')
parser.add_argument('-v', dest='version', help='force mini version')
parser.add_argument('--sel', dest='selection')
parser.add_argument('--prw', action='store_true', help='apply prw weights')
parser.add_argument('--data', help='Include data: data|data15|data16')
parser.add_argument('--unblind', action='store_true', help='Unblind data')
# backgrounds
parser.add_argument('--mc', action='store_true', help='Use MC backgrounds')
parser.add_argument('--muq', help='Normalization factor for gam+jet')
parser.add_argument('--muw', help='Normalization factor for W gamma')
parser.add_argument('--mut', help='Normalization factor for ttbar gamma')
# signal
parser.add_argument('--signal', action='store_true', help='Include signal')
parser.add_argument('--m3', default='1400', help='M3')
# others
parser.add_argument('--latex',
action='store_true',
help='use LatexTable instead PrettyTable')
parser.add_argument('--nw', action='store_true')
if len(sys.argv) < 2:
parser.print_usage()
sys.exit(1)
args = parser.parse_args()
## samples
bkgs = analysis.backgrounds_mc
dd_scale = 1.
if args.data is None and args.samples is None and args.lumi is not None:
bkgs.append('jfake')
bkgs.append('efake')
dd_scale = float(args.lumi) * 1000. / analysis.lumi_data
elif args.data == 'data15':
args.lumi = 'data15'
bkgs.append('jfake15')
bkgs.append('efake15')
elif args.data == 'data16':
args.lumi = 'data16'
bkgs.append('jfake16')
bkgs.append('efake16')
elif args.data == 'data':
args.lumi = 'data'
bkgs.append('jfake')
bkgs.append('efake')
if args.mc:
bkgs = [
'photonjet',
'multijet',
'wgamma',
'zgamma',
'ttbar',
'ttbarg',
'vjets',
]
signal = []
for (m3, mu) in sorted(grid_m3_mu.iterkeys()):
if int(args.m3) == m3:
signal.append('GGM_M3_mu_%d_%d' % (m3, mu))
if args.prw:
get_events = partial(miniutils.get_events,
lumi=args.lumi,
version=args.version,
prw=True)
elif args.nw:
get_events = partial(miniutils.get_events,
lumi=args.lumi,
version=args.version,
scale=False)
else:
get_events = partial(miniutils.get_events,
lumi=args.lumi,
version=args.version)
if args.regions:
regions = args.regions.split(',')
samples = args.samples.split(',') if args.samples is not None else []
if args.selection is not None:
regions = []
regions.append(args.selection)
if args.latex:
table = LatexTable()
else:
table = PrettyTable()
if samples:
table.add_column('', [s for s in samples])
elif args.data and args.signal:
table.add_column('', [
'Data',
] + bkgs + ['Total bkg'] + signal)
elif args.data:
table.add_column('', [
'Data',
] + bkgs + ['Total bkg'])
elif args.signal:
table.add_column('', bkgs + ['Total bkg'] + signal)
else:
table.add_column('', bkgs + ['Total bkg'])
for region in regions:
if not region:
continue
try:
selection = getattr(regions_, region)
except:
selection = region
cols = OrderedDict()
if samples:
for sample in samples:
evts = get_events(sample, region=region, selection=selection)
cols[sample] = evts
else:
# Data
if args.data is None:
pass
elif 'SR' in region and not args.unblind:
cols['data'] = '-1'
else:
cols['data'] = get_events(args.data,
region=region,
selection=selection)
# Bkgs
total_bkg = Value(0)
for sample in bkgs:
evts = get_events(sample, region=region, selection=selection)
if args.data is None and 'fake' in sample:
evts *= dd_scale
if not region.startswith('CR'):
if args.muq is not None and sample == 'photonjet':
evts *= float(args.muq)
if args.muw is not None and sample == 'wgamma':
evts *= float(args.muw)
if args.mut is not None and sample == 'ttbarg':
evts *= float(args.mut)
cols[sample] = evts
total_bkg += evts
cols['Total bkg'] = total_bkg
if region.startswith('CR') and args.data:
if 'CRQ' in region or 'CRM' in region:
mu = (cols['data'] -
(total_bkg - cols['photonjet'])) / cols['photonjet']
purity = cols['photonjet'] / total_bkg
cols['photonjet'] = '%s (%.2f, mu=%.2f)' % (
cols['photonjet'], purity.mean, mu.mean)
elif 'CRT' in region:
mu = (cols['data'] -
(total_bkg - cols['ttbarg'])) / cols['ttbarg']
purity = cols['ttbarg'] / total_bkg
cols['ttbarg'] = '%s (%.2f%%, mu=%.2f)' % (
cols['ttbarg'], purity.mean, mu.mean)
elif 'CRW' in region:
mu = (cols['data'] -
(total_bkg - cols['wgamma'])) / cols['wgamma']
purity = cols['wgamma'] / total_bkg
cols['wgamma'] = '%s (%.2f%%, mu=%.2f)' % (
cols['wgamma'], purity.mean, mu.mean)
# Signals
if args.signal:
for sig in signal:
n_s = get_events(sig, region=region, selection=selection)
cols[sig] = '%s (%s)' % (n_s,
get_significance(n_s, total_bkg))
table.add_column(region[:10], cols.values())
print table
def main():
parser = argparse.ArgumentParser(description='get yields')
parser.add_argument('-r', dest='regions', default='', help='Regions separated with ,')
parser.add_argument('-s', dest='samples', help='Samples separated with ,')
parser.add_argument('-i', dest='files', help='Files separated with ,')
parser.add_argument('-l', dest='lumi', help='Luminosity to scale')
parser.add_argument('-v', dest='version', help='force mini version')
parser.add_argument('--sel', dest='selection')
parser.add_argument('--prw', action='store_true', help='apply prw weights')
parser.add_argument('--data', help='Include data: data|data15|data16')
parser.add_argument('--unblind', action='store_true', help='Unblind data')
# backgrounds
parser.add_argument('--mc', action='store_true', help='Use MC backgrounds')
parser.add_argument('--muq', help='Normalization factor for gam+jet')
parser.add_argument('--muw', help='Normalization factor for W gamma')
parser.add_argument('--mut', help='Normalization factor for ttbar gamma')
# signal
parser.add_argument('--signal', action='store_true', help='Include signal')
parser.add_argument('--m3', default='1400', help='M3')
# others
parser.add_argument('--latex', action='store_true', help='use LatexTable instead PrettyTable')
parser.add_argument('--nw', action='store_true')
if len(sys.argv) < 2:
parser.print_usage()
sys.exit(1)
args = parser.parse_args()
## samples
bkgs = analysis.backgrounds_mc
dd_scale = 1.
if args.data is None and args.samples is None and args.lumi is not None:
bkgs.append('jfake')
bkgs.append('efake')
dd_scale = float(args.lumi) * 1000. / analysis.lumi_data
elif args.data == 'data15':
args.lumi = 'data15'
bkgs.append('jfake15')
bkgs.append('efake15')
elif args.data == 'data16':
args.lumi = 'data16'
bkgs.append('jfake16')
bkgs.append('efake16')
elif args.data == 'data':
args.lumi = 'data'
bkgs.append('jfake')
bkgs.append('efake')
if args.mc:
bkgs = [
'photonjet',
'multijet',
'wgamma',
'zgamma',
'ttbar',
'ttbarg',
'vjets',
]
signal = []
for (m3, mu) in sorted(grid_m3_mu.iterkeys()):
if int(args.m3) == m3:
signal.append('GGM_M3_mu_%d_%d' % (m3, mu))
if args.prw:
get_events = partial(miniutils.get_events, lumi=args.lumi, version=args.version, prw=True)
elif args.nw:
get_events = partial(miniutils.get_events, lumi=args.lumi, version=args.version, scale=False)
else:
get_events = partial(miniutils.get_events, lumi=args.lumi, version=args.version)
if args.regions:
regions = args.regions.split(',')
samples = args.samples.split(',') if args.samples is not None else []
if args.selection is not None:
regions = []
regions.append(args.selection)
if args.latex:
table = LatexTable()
else:
table = PrettyTable()
if samples:
table.add_column('', [s for s in samples])
elif args.data and args.signal:
table.add_column('', ['Data',]+bkgs+['Total bkg']+signal)
elif args.data:
table.add_column('', ['Data',]+bkgs+['Total bkg'])
elif args.signal:
table.add_column('', bkgs+['Total bkg']+signal)
else:
table.add_column('', bkgs+['Total bkg'])
for region in regions:
if not region:
continue
try:
selection = getattr(regions_, region)
except:
selection = region
cols = OrderedDict()
if samples:
for sample in samples:
evts = get_events(sample, region=region, selection=selection)
cols[sample] = evts
else:
# Data
if args.data is None:
pass
elif 'SR' in region and not args.unblind:
cols['data'] = '-1'
else:
cols['data'] = get_events(args.data, region=region, selection=selection)
# Bkgs
total_bkg = Value(0)
for sample in bkgs:
evts = get_events(sample, region=region, selection=selection)
if args.data is None and 'fake' in sample:
evts *= dd_scale
if not region.startswith('CR'):
if args.muq is not None and sample == 'photonjet':
evts *= float(args.muq)
if args.muw is not None and sample == 'wgamma':
evts *= float(args.muw)
if args.mut is not None and sample == 'ttbarg':
evts *= float(args.mut)
cols[sample] = evts
total_bkg += evts
cols['Total bkg'] = total_bkg
if region.startswith('CR') and args.data:
if 'CRQ' in region or 'CRM' in region:
mu = (cols['data']-(total_bkg-cols['photonjet']))/cols['photonjet']
purity = cols['photonjet'] / total_bkg
cols['photonjet'] = '%s (%.2f, mu=%.2f)' % (cols['photonjet'], purity.mean, mu.mean)
elif 'CRT' in region:
mu = (cols['data']-(total_bkg-cols['ttbarg']))/cols['ttbarg']
purity = cols['ttbarg'] / total_bkg
cols['ttbarg'] = '%s (%.2f%%, mu=%.2f)' % (cols['ttbarg'], purity.mean, mu.mean)
elif 'CRW' in region:
mu = (cols['data']-(total_bkg-cols['wgamma']))/cols['wgamma']
purity = cols['wgamma'] / total_bkg
cols['wgamma'] = '%s (%.2f%%, mu=%.2f)' % (cols['wgamma'], purity.mean, mu.mean)
# Signals
if args.signal:
for sig in signal:
n_s = get_events(sig, region=region, selection=selection)
cols[sig] = '%s (%s)' % (n_s, get_significance(n_s, total_bkg))
table.add_column(region[:10], cols.values())
print table
def systable(workspace, samples, channels, output_name):
chan_str = channels.replace(",","_")
chan_list = channels.split(",")
chosen_sample = False
if samples:
sample_str = samples.replace(",","_") + "_"
from cmdLineUtils import cmdStringToListOfLists
sample_list = cmdStringToListOfLists(samples)
chosen_sample = True
show_percent = True
doAsym = True
result_name = 'RooExpandedFitResult_afterFit'
skip_list = ['sqrtnobsa', 'totbkgsysa', 'poisqcderr','sqrtnfitted','totsyserr','nfitted']
chan_sys = {}
orig_chan_list = list(chan_list)
chan_list = []
# calculate the systematics breakdown for each channel/region given in chanList
# choose whether to use method-1 or method-2
# choose whether calculate systematic for full model or just a sample chosen by user
for chan in orig_chan_list:
if not chosen_sample:
reg_sys = latexfitresults(workspace, chan, '', result_name, 'obsData', doAsym)
chan_sys[chan] = reg_sys
chan_list.append(chan)
else:
for sample in sample_list:
sample_name = getName(sample)
reg_sys = latexfitresults(workspace, chan, sample, result_name, 'obsData', doAsym)
chan_sys[chan+"_"+sample_name] = reg_sys
chan_list.append(chan+"_"+sample_name)
# write out LaTeX table by calling function from SysTableTex.py function tablefragment
#line_chan_sys_tight = tablefragment(chanSys,chanList,skiplist,chanStr,showPercent)
if not chosen_sample:
field_names = ['\\textbf{Uncertainties}',] + [ '\\textbf{%s}' % reg for reg in chan_list ]
elif len(sample_list) == 1:
sample_label = labels_latex_dict.get(getName(sample_list[0]), getName(sample_list[0]))
field_names = ['\\textbf{Uncertainties (%s)}' % sample_label ] + [ '\\textbf{%s}' % (reg.split('_')[0]) for reg in chan_list ]
else:
field_names = ['\\textbf{Uncertainties}',] + [ '\\textbf{%s (%s)}' % (reg.split('_')[0], reg.split('_')[1]) for reg in chan_list ]
align = ['l',] + [ 'r' for i in chan_list ]
tablel = LatexTable(field_names, align=align, env=True)
# print the total fitted (after fit) number of events
row = ['Total background expectation',]
for region in chan_list:
row.append("$%.2f$" % chan_sys[region]['nfitted'])
tablel.add_row(row)
tablel.add_line()
# print sqrt(N_obs) - for comparison with total systematic
row = ['Total statistical $(\\sqrt{N_\\mathrm{exp}})$',]
for region in chan_list:
row.append("$\\pm %.2f$" % chan_sys[region]['sqrtnfitted'])
tablel.add_row(row)
# print total systematic uncertainty
row = [ 'Total background systematic', ]
for region in chan_list:
percentage = chan_sys[region]['totsyserr']/chan_sys[region]['nfitted'] * 100.0
row.append("$\\pm %.2f\ [%.2f\%%]$" % (chan_sys[region]['totsyserr'], percentage))
tablel.add_row(row)
tablel.add_line()
tablel.add_line()
# print systematic uncertainty per floated parameter (or set of parameters, if requested)
d = chan_sys[chan_list[0]]
m_listofkeys = sorted(d.iterkeys(), key=lambda k: d[k], reverse=True)
# uncertanties dict
unc_dict = dict()
unc_order = []
for name in m_listofkeys:
if name in skip_list:
continue
printname = name.replace('syserr_','')
#slabel = label.split('_')
#label = 'MC stat. (%s)' % slabel[2]
# skip negligible uncertainties in all requested regions:
zero = True
for index, region in enumerate(chan_list):
percentage = chan_sys[region][name]/chan_sys[region]['nfitted'] * 100.0
if ('%.4f' % chan_sys[region][name]) != '0.0000' and ('%.2f' % percentage) != '0.00':
zero = False
if zero:
continue
# Parameter name -> parameter label
if printname.startswith('gamma_stat'):
label = 'MC stat.'
elif printname.startswith('gamma_shape_JFAKE_STAT_jfake'):
label = 'jet $\\to\\gamma$ fakes stat.'
elif printname.startswith('gamma_shape_EFAKE_STAT_efake'):
label = '$e\\to\\gamma$ fakes stat.'
else:
if printname in systdict and systdict[printname]:
label = systdict[printname]
else:
label = printname
# Fill dict
for index, region in enumerate(chan_list):
if printname.startswith('gamma') and not region.split('_')[0] in printname:
continue
if not label in unc_dict:
unc_dict[label] = []
unc_order.append(label)
if not show_percent:
unc_dict[label].append("$\\pm %.2f$" % chan_sys[region][name])
else:
percentage = chan_sys[region][name]/chan_sys[region]['nfitted'] * 100.0
if percentage < 1:
unc_dict[label].append("$\\pm %.2f\ [%.2f\%%]$" % (chan_sys[region][name], percentage))
else:
unc_dict[label].append("$\\pm %.2f\ [%.1f\%%]$" % (chan_sys[region][name], percentage))
# fill table
for label in unc_order:
tablel.add_row([label,] + unc_dict[label])
tablel.add_line()
tablel.save_tex(output_name)
def yieldstable(workspace, samples, channels, output_name, table_name, is_cr=False, show_before_fit=False, unblind=True):
if is_cr:
show_before_fit=True
normalization_factors = get_normalization_factors(workspace)
#sample_str = samples.replace(",","_")
from cmdLineUtils import cmdStringToListOfLists
samples_list = cmdStringToListOfLists(samples)
regions_list = [ '%s_cuts' % r for r in channels.split(",") ]
#samples_list = samples.split(",")
# call the function to calculate the numbers, or take numbers from pickle file
if workspace.endswith(".pickle"):
print "READING PICKLE FILE"
f = open(workspace, 'r')
m = pickle.load(f)
f.close()
else:
#m = YieldsTable.latexfitresults(workspace, regions_list, samples_list, 'obsData')
m = latexfitresults(workspace, regions_list, samples_list)
with open(output_name.replace('.tex', '.pickle'), 'w') as f:
pickle.dump(m, f)
regions_names = [ region.replace("_cuts", "").replace('_','\_') for region in m['names'] ]
field_names = [table_name,] + regions_names
align = ['l',] + [ 'r' for i in regions_names ]
samples_list_decoded = []
for isam, sample in enumerate(samples_list):
sampleName = getName(sample)
samples_list_decoded.append(sampleName)
samples_list = samples_list_decoded
tablel = LatexTable(field_names, align=align, env=True)
tablep = PrettyTable(field_names, align=align)
# number of observed events
if unblind:
row = ['Observed events',] + [ '%d' % n for n in m['nobs'] ]
else:
row = ['Observed events',] + [ '-' for n in m['nobs'] ]
tablel.add_row(row)
tablep.add_row(row)
tablel.add_line()
tablep.add_line()
#print the total fitted (after fit) number of events
# if the N_fit - N_error extends below 0, make the error physical , meaning extend to 0
rowl = ['Expected SM events', ]
rowp = ['Expected SM events', ]
for index, n in enumerate(m['TOTAL_FITTED_bkg_events']):
if (n - m['TOTAL_FITTED_bkg_events_err'][index]) > 0. :
rowl.append('$%.2f \pm %.2f$' % (n, m['TOTAL_FITTED_bkg_events_err'][index]))
rowp.append('%.2f ± %.2f' % (n, m['TOTAL_FITTED_bkg_events_err'][index]))
else:
#print "WARNING: negative symmetric error after fit extends below 0. for total bkg pdf: will print asymmetric error w/ truncated negative error reaching to 0."
rowl.append('$%.2f_{-%.2f}^{+%.2f}$' % (n, n, m['TOTAL_FITTED_bkg_events_err'][index]))
rowp.append('%.2f -%.2f +%.2f' % (n, n, m['TOTAL_FITTED_bkg_events_err'][index]))
tablel.add_row(rowl)
tablel.add_line()
tablep.add_row(rowp)
tablep.add_line()
map_listofkeys = m.keys()
# print fitted number of events per sample
# if the N_fit - N_error extends below 0, make the error physical , meaning extend to 0
for sample in samples_list:
for name in map_listofkeys:
rowl = []
rowp = []
if not "Fitted_events_" in name:
continue
sample_name = name.replace("Fitted_events_", "")
if sample_name != sample:
continue
rowl.append('%s' % labels_latex_dict.get(sample_name, sample_name).replace('_', '\_'))
rowp.append('%s' % labels_html_dict.get(sample_name, sample_name))
for index, n in enumerate(m[name]):
if ((n - m['Fitted_err_'+sample][index]) > 0.) or not abs(n) > 0.00001:
rowl.append('$%.2f \\pm %.2f$' % (n, m['Fitted_err_'+sample][index]))
rowp.append('%.2f ± %.2f' % (n, m['Fitted_err_'+sample][index]))
else:
#print "WARNING: negative symmetric error after fit extends below 0. for sample", sample, " will print asymmetric error w/ truncated negative error reaching to 0."
rowl.append('$%.2f_{-%.2f}^{+%.2f}$' % (n, n, m['Fitted_err_'+sample][index]))
rowp.append('%.2f -%.2f +%.2f' % (n, n, m['Fitted_err_'+sample][index]))
tablel.add_row(rowl)
tablep.add_row(rowp)
tablel.add_line()
tablep.add_line()
# print the total expected (before fit) number of events
if show_before_fit:
# if the N_fit - N_error extends below 0, make the error physical , meaning extend to 0
rowl = ['Before SM events',]
rowp = ['(before fit) SM events',]
total_before = []
purity_before = []
for index, n in enumerate(m['TOTAL_MC_EXP_BKG_events']):
if regions_names[index].startswith('CR'):
total_before.append(n)
rowl.append('$%.2f$' % n)
rowp.append('%.2f' % n)
tablel.add_row(rowl)
tablel.add_line()
tablep.add_row(rowp)
tablep.add_line()
map_listofkeys = m.keys()
# print expected number of events per sample
# if the N_fit - N_error extends below 0, make the error physical , meaning extend to 0
for sample in samples_list:
for name in map_listofkeys:
rowl = []
rowp = []
if "MC_exp_events_" in name and sample in name:
sample_name = name.replace("MC_exp_events_","")
if sample_name != sample:
continue
rowl.append('(before fit) %s' % labels_latex_dict.get(sample_name, sample_name).replace('_', '\_'))
rowp.append('(before fit) %s' % labels_html_dict.get(sample_name, sample_name))
for index, n in enumerate(m[name]):
if regions_names[index] == 'CRQ' and sample == 'photonjet':
purity_before.append(n)
if regions_names[index] == 'CRW' and sample == 'wgamma':
purity_before.append(n)
if regions_names[index] == 'CRT' and sample == 'ttbarg':
purity_before.append(n)
rowl.append('$%.2f$' % n)
rowp.append('%.2f' % n)
tablel.add_row(rowl)
tablep.add_row(rowp)
tablel.add_line()
tablep.add_line()
if show_before_fit and all([r.startswith('CR') for r in regions_names]) and normalization_factors is not None:
tablel.add_row(['', '', '', ''])
tablel.add_line()
tablep.add_row(['', '', '', ''])
tablep.add_line()
# purity
rowl = ['Background purity',]
rowp = ['Background purity',]
for index, region in enumerate(regions_names):
purity = int(purity_before[index]/total_before[index] * 100.)
rowl.append('$%i\%%$' % purity)
rowp.append('%i%%' % purity)
tablel.add_row(rowl)
tablel.add_line()
tablep.add_row(rowp)
tablep.add_line()
# normalization
rowl = ['Normalization factor ($\mu$)',]
rowp = ['Normalization factor (mu)',]
for region in regions_names:
rowl.append('$%.2f \pm %.2f$' % normalization_factors[region])
rowp.append('%.2f ± %.2f' % normalization_factors[region])
tablel.add_row(rowl)
tablel.add_line()
tablep.add_row(rowp)
tablep.add_line()
tablel.save_tex(output_name)
with open(output_name.replace('.tex', '.html'), 'w+') as f:
f.write(tablep.get_html_string())
def plot_energy_spectra():
mus = []
widths = []
energies = []
#leer = TkaFile("data/EnergiespektrumLeer.TKA")
with LatexTable("out/calib_peaks.tex") as peaktable, LatexTable(
"out/rates.tex") as ratetable:
peaktable.header("El.",
"Höhe",
r"Channel $x_\textrm{max}$",
r"Breite $\Delta x$",
r'$\chi^2/\textrm{ndf}$',
"Energie / keV",
lineafter=1)
ratetable.header("El.", "Events", "Messzeit", "Rate")
for filename, meta in energy_spectra.items():
peaktable.hline()
tka = TkaFile("data/" + filename)
x = np.arange(len(tka))
#y = tka.data - leer.data
y = tka.data
#errors = np.sqrt(tka.data + leer.data + 2)
errors = np.sqrt(tka.data + 1)
plt.clf()
plt.plot(x, y, ',', color="black")
for i, (mu0, sigma0, energy,
sigma_energy) in enumerate(meta["peaks"], 1):
fit = local_fit(x, y, errors, mu=mu0, sigma=sigma0)
fit.plot(fit.mu - 5 * fit.sigma,
fit.mu + 5 * fit.sigma,
1000,
zorder=10000,
color="red")
mus.append((fit.mu, fit.error_mu))
if meta["element"] in ("Na", "Cs"):
E_gamma = 0.09863 * fit.mu - 19.056
m_electron = 511 # keV
E_compton = E_gamma / (1 + m_electron / (2 * E_gamma))
c_compton = (E_compton + 19.056) / 0.09863
plt.axvline(c_compton, color="red", linestyle="--")
peaktable.row((meta["element"], len(meta["peaks"])),
formatQuantityLatex(fit.A, fit.error_A),
formatQuantityLatex(fit.mu, fit.error_mu),
formatQuantityLatex(fit.sigma, fit.error_sigma),
"%.2f" % fit.chi2ndf,
formatQuantityLatex(energy, sigma_energy))
widths.append((fit.sigma, fit.error_sigma))
energies.append((energy, sigma_energy))
#print(meta["element"], i, fit)
plt.xlabel("Kanal")
plt.ylabel("Count")
plt.xlim(0, 2**14)
plt.title(meta["title"])
plt.savefig("out/" + clean_filename(filename) + "_all." + SAVETYPE)
N = ufloat(y.sum(), errors.sum())
t = ufloat(tka.real_time, 1 / math.sqrt(12))
m = N / t # Hz/Bq
r = ufloat(91.5, 0.01) # mm
A = ufloat(*meta["activity"]) * 1000 # Bq
I_g = 1
r = ufloat(15, 5)
F_D = ufloat(7.45, 0.05) * ufloat(80.75, 0.05) # mm^2
efficiency = 4 * math.pi * r**2 * m / (F_D * A * I_g)
print("Efficiency:", meta["element"], efficiency)
ratetable.row(meta["element"], formatUFloatLatex(N),
formatUFloatLatex(t, unit="s"),
formatUFloatLatex(m, unit="1/s"))
mus, error_mus = np.array(mus).T
widths, error_widths = np.array(widths).T
energies, error_energies = np.array(energies).T
# Kalibration
plt.clf()
fit = Fit(LINEAR)
fit.slope = 0.1
fit.offset = -20
for i in range(5):
errors = fit.combine_errors(mus, error_mus, error_energies)
fit.fit(mus, energies, errors)
plt.errorbar(mus,
energies,
xerr=error_mus,
yerr=error_energies,
fmt=',',
color="black")
fit.plot(box='tl',
units={
"slope": "eV / Channel",
"offset": "eV"
},
factors={
"slope": 1000,
"offset": 1000
},
color="red")
plt.xlabel("Kanal")
plt.ylabel("Energie / keV")
plt.savefig("out/calib_fit." + SAVETYPE)
plt.clf()
errs = fit.combine_errors(mus, xerr=error_mus, yerr=error_energies)
fit.plot_residual(mus, energies, errs, box='tl', fmt=',', color="black")
plt.xlabel("Kanal")
plt.ylabel("Energie / keV")
plt.savefig("out/calibresiduum." + SAVETYPE)
s = formatQuantityLatex(fit.slope * 1000,
fit.error_slope * 1000,
unit="eV / Kanal",
math=False)
o = formatQuantityLatex(fit.offset * 1000,
fit.error_offset * 1000,
unit="eV",
math=False)
with open('out/calib.tex', 'w') as file:
file.write(
r'Die in diesem Versuch verwendeten Einstellungen f\"uhren zu einer Einteilung von \[ '
+ s + r' \] wobei der erste Kanal die Energie \[ ' + o +
r' \] besitzt.')
# Energieauflösung
error_widths = np.sqrt(
np.power(fit.error_slope * widths, 2) +
np.power(error_widths * fit.slope, 2))
widths = widths * fit.slope
error_energies = np.sqrt(
np.power(fit.error_offset, 2) + np.power(mus * fit.error_slope, 2) +
np.power(fit.slope * error_mus, 2))
energies = fit.slope * mus + fit.offset
X = energies
Y = widths
SX = error_energies
SY = error_widths
func = lambda E, a, b: np.sqrt(np.power(a * E, 2) + np.power(b, 2) * E)
fit = Fit(func)
fit.a = 0.01
fit.b = 0.01
for _ in range(10):
err = fit.combine_errors(X, SX, SY)
fit.fit(X, Y, err)
plt.clf()
plt.errorbar(X, Y, xerr=SX, yerr=SY, fmt=',', color="black")
fit.plot(box='br', units={'b': r'\sqrt{\textrm{keV}}'}, color="red")
plt.xlabel(r"$ E $ / keV")
plt.ylabel(r"$ \Delta E / keV$")
plt.title(
r'Energieauflösung: Fit zu $ \Delta E = \sqrt{\left(a E\right)^2 + b^2 E} $'
)
plt.savefig("out/energyresolution_fit." + SAVETYPE)
print("a =", formatQuantity(fit.a, fit.error_a))
print("b =", formatQuantity(fit.b, fit.error_b))
plt.clf()
err = fit.combine_errors(X, SX, SY)
fit.plot_residual(X, Y, err, box='tr', fmt=",", color="black")
plt.xlabel(r"$ E $ / keV")
plt.ylabel(r"$ \Delta E / keV$")
plt.title("Energieauflösung: Residuen")
plt.savefig("out/energyresolution_residual." + SAVETYPE)
with LatexTable("out/energyresolution.tex") as table:
table.header("Parameter", "Wert")
table.row("$a$", formatQuantityLatex(fit.a, fit.error_a))
table.row("$b$",
formatQuantityLatex(fit.b, fit.error_b, unit="\sqrt{keV}"))
def yieldstable(workspace,
samples,
channels,
output_name,
table_name='',
show_before_fit=False,
unblind=True,
show_cr_info=False,
cr_dict={}):
if show_cr_info:
show_before_fit = True
normalization_factors = get_normalization_factors(workspace)
samples_list = cmdStringToListOfLists(samples)
regions_list = ['%s_cuts' % r for r in channels.split(",")]
# call the function to calculate the numbers, or take numbers from pickle file
if workspace.endswith(".pickle"):
print "Reading from pickle file"
f = open(workspace, 'r')
m = pickle.load(f)
f.close()
else:
#m = YieldsTable.latexfitresults(workspace, regions_list, samples_list, 'obsData')
m = latexfitresults(workspace, regions_list, samples_list)
with open(output_name.replace('.tex', '.pickle'), 'w') as f:
pickle.dump(m, f)
regions_names = [
region.replace("_cuts", "").replace('_', '\_') for region in m['names']
]
field_names = [
table_name,
] + regions_names
align = [
'l',
] + ['r' for i in regions_names]
samples_list_decoded = []
for isam, sample in enumerate(samples_list):
sampleName = getName(sample)
samples_list_decoded.append(sampleName)
samples_list = samples_list_decoded
tablel = LatexTable(field_names, align=align, env=True)
# number of observed events
if unblind:
row = [
'Observed events',
] + ['%d' % n for n in m['nobs']]
else:
row = [
'Observed events',
] + ['-' for n in m['nobs']]
tablel.add_row(row)
tablel.add_line()
# Total fitted (after fit) number of events
# if the N_fit - N_error extends below 0, make the error physical, meaning extend to 0
rowl = [
'Expected SM events',
]
for index, n in enumerate(m['TOTAL_FITTED_bkg_events']):
if (n - m['TOTAL_FITTED_bkg_events_err'][index]) > 0.:
rowl.append('$%.2f \pm %.2f$' %
(n, m['TOTAL_FITTED_bkg_events_err'][index]))
else:
rowl.append('$%.2f_{-%.2f}^{+%.2f}$' %
(n, n, m['TOTAL_FITTED_bkg_events_err'][index]))
tablel.add_row(rowl)
tablel.add_line()
map_listofkeys = m.keys()
# After fit number of events per sample (if the N_fit-N_error extends below 0, make the error physical, meaning extend to 0)
for sample in samples_list:
for name in map_listofkeys:
rowl = []
if not "Fitted_events_" in name:
continue
sample_name = name.replace("Fitted_events_", "")
if sample_name != sample:
continue
rowl.append('%s' % labels_latex_dict.get(
sample_name, sample_name).replace('_', '\_'))
for index, n in enumerate(m[name]):
if ((n - m['Fitted_err_' + sample][index]) >
0.) or not abs(n) > 0.00001:
rowl.append('$%.2f \\pm %.2f$' %
(n, m['Fitted_err_' + sample][index]))
else:
rowl.append('$%.2f_{-%.2f}^{+%.2f}$' %
(n, n, m['Fitted_err_' + sample][index]))
tablel.add_row(rowl)
tablel.add_line()
# Total expected (before fit) number of events
if show_before_fit:
# if the N_fit - N_error extends below 0, make the error physical, meaning extend to 0
rowl = [
'Before fit SM events',
]
total_before = {}
purity_before = {}
for index, n in enumerate(m['TOTAL_MC_EXP_BKG_events']):
reg_name = regions_names[index]
if cr_dict and reg_name in cr_dict:
total_before[reg_name] = n
rowl.append('$%.2f$' % n)
tablel.add_row(rowl)
tablel.add_line()
map_listofkeys = m.keys()
# Expected number of events per sample (if the N_fit - N_error extends below 0, make the error physical, meaning extend to 0)
for sample in samples_list:
for name in map_listofkeys:
rowl = []
if "MC_exp_events_" in name and sample in name:
sample_name = name.replace("MC_exp_events_", "")
if sample_name != sample:
continue
rowl.append('Before fit %s' % labels_latex_dict.get(
sample_name, sample_name).replace('_', '\_'))
for index, n in enumerate(m[name]):
reg_name = regions_names[index]
if cr_dict and reg_name in cr_dict and sample == cr_dict[
reg_name]:
purity_before[reg_name] = n
rowl.append('$%.2f$' % n)
tablel.add_row(rowl)
tablel.add_line()
if show_cr_info and normalization_factors is not None:
tablel.add_row(['' for i in range(len(regions_names) + 1)])
tablel.add_line()
# purity
rowl = [
'Background purity',
]
for region in regions_names:
try:
purity = int(
round(purity_before[region] / total_before[region] * 100.))
rowl.append('$%i\%%$' % purity)
except:
rowl.append('-')
tablel.add_row(rowl)
tablel.add_line()
# normalization
rowl = [
'Normalization factor ($\mu$)',
]
for region in regions_names:
try:
rowl.append('$%.2f \pm %.2f$' % normalization_factors[region])
except:
rowl.append('-')
tablel.add_row(rowl)
tablel.add_line()
tablel.save_tex(output_name)
def energieaufloesung(calibration, plot=True):
print("##### ENERGY RESOLUTION #####")
energies = []
widths = []
sigma_energies = []
sigma_widths = []
for filename, meta in kalib.items():
experiment = Experiment("data/" + filename,
title=meta["title"],
calibration=calibration)
for peak in meta["peaks"]:
mu0, sigma0 = peak[0], peak[1]
fit = experiment.find_peak(mu0, sigma0, plot=False)
energies.append(experiment.channel2energy(fit.mu))
widths.append(experiment.channelwidth2energywidth(fit.sigma))
sigma_energies.append(
experiment.channelwidth2energywidth(fit.sigma_mu))
sigma_widths.append(
experiment.channelwidth2energywidth(fit.sigma_sigma))
for filename, meta in data.items():
experiment = Experiment("data/" + filename,
title=filename,
calibration=calibration)
experiment.subtract_empty("data/G20_Leer.mca", 0.5)
for peak in meta["peaks"]:
mu0, sigma0 = peak[0], peak[1]
fit = experiment.find_peak(mu0, sigma0, plot=False)
energies.append(experiment.channel2energy(fit.mu))
widths.append(experiment.channelwidth2energywidth(fit.sigma))
sigma_energies.append(
experiment.channelwidth2energywidth(fit.sigma_mu))
sigma_widths.append(
experiment.channelwidth2energywidth(fit.sigma_sigma))
energies = np.array(energies)
widths = np.array(widths)
sigma_energies = np.array(sigma_energies)
sigma_widths = np.array(sigma_widths)
X = energies
Y = np.power(widths, 2)
SX = sigma_energies
SY = 2 * widths * sigma_widths
func = lambda x, a0, a1, : a0 + x * a1 #+np.power(x,2)*a2
fit = Fit(func)
fit.a0 = 1
fit.a1 = 1
for _ in range(10):
err = fit.combine_errors(X, SX, SY)
fit.fit(X, Y, err)
if plot:
plt.clf()
plt.errorbar(X, Y, xerr=SX, yerr=SY, fmt=',')
fit.plot(np.min(X),
np.max(X),
box='br',
units={
'a0': 'keV',
'a1': r'\sqrt{keV}'
})
plt.xlabel(r"$ E $ / keV")
plt.ylabel(r"$ \Delta E^2 / keV^2$")
plt.title(r'Energieauflösung: Fit zu $ \Delta E^2 = a_0 + a_1 E $'
) # \oplus \frac{c}{E}
plt.savefig("out/energyresolution_fit." + SAVETYPE)
plt.clf()
err = fit.combine_errors(X, SX, SY)
fit.plot_residuums(X, Y, err, box='tr', fmt=",")
plt.xlabel(r"$ E $ / keV")
plt.ylabel(r"$ \Delta E^2 / keV^2$")
plt.title("Energieauflösung: Residuen")
plt.savefig("out/energyresolution_residuum." + SAVETYPE)
with LatexTable("out/energyresolution.tex") as table:
table.header("Parameter", "Wert")
table.row("$a_0$", format_error(fit.a0, fit.sigma_a0, unit="keV^2"))
table.row("$a_1$", format_error(fit.a1, fit.sigma_a1, unit="keV"))
table.hline()
a = math.sqrt(fit.a0)
b = math.sqrt(fit.a1)
sa = 0.5 * fit.sigma_a0 / a
sb = 0.5 * fit.sigma_a1 / b
table.row("$a$", format_error(a, sa, unit="keV"))
table.row("$b$", format_error(b, sb, unit="\sqrt{keV}"))
with LatexTable("out/energyresolution_examples.tex") as table:
energies = np.linspace(10, 60, 6)
sigmas = np.sqrt(fit.apply(energies))
deltas = sigmas * 2 * math.sqrt(2 * math.log(2))
table.header("Energie",
"Auflösung",
"Relative Auflösung",
"FWHM",
lineafter=0)
table.row("$E$", "$\sigma$", "$\sigma / E$",
"$2 \sqrt{2 \ln{2}} \sigma$")
table.hline(2)
for energy, sigma, delta in zip(energies, sigmas, deltas):
e = "%d keV" % energy
s = _n(sigma * 1000) + " eV"
d = "%d eV" % (delta * 1000)
table.row(e, s, _n(sigma / energy * 100) + r"\%", d)
def auswertung(calibration, plot=True, smooth=False):
print("##### UNKNOWN #####")
with LatexTable("out/test_peaks.tex") as peaktable, LatexTable(
"out/test_counts.tex") as counttable:
peaktable.header("Probe", "Höhe", "Energie", "Breite", lineafter=0)
peaktable.row("", "", r"$E_\textrm{max}$", r"$\Delta E$")
peaktable.hline()
counttable.header("Element", "Messdauer", "Ereignisse", "korrigiert",
"Anteil")
leer = Experiment("data/G20_Leer.mca")
counttable.row(
"Leermessung",
r'$' + leer.mcameta["Accumulation Time"] + r' \unit{s}$',
leer.mcameta["Slow Count"], "-", "-")
counttable.hline()
for filename, meta in data.items():
peaktable.hline()
#print("="*10, filename, "="*10)
experiment = Experiment("data/" + filename,
title=meta["title"],
calibration=calibration)
count = int(experiment.mcameta["Slow Count"])
reduced = int(count - 0.5 * int(leer.mcameta["Slow Count"]))
percentage = "%.1f \\%%" % (reduced / count * 100)
counttable.row(
meta["title"],
r'$' + experiment.mcameta["Accumulation Time"] + r' \unit{s}$',
count, reduced, percentage)
if plot:
plt.clf()
experiment.plot()
plt.title("Probe: " + meta["title"] + " - Rohdaten")
plt.xlim(0, 4096)
plt.savefig("out/" + clean_filename(filename) + "_raw." +
SAVETYPE)
experiment.subtract_empty("data/G20_Leer.mca", 0.5)
if smooth:
experiment.smooth(0.1)
if plot:
plt.clf()
experiment.errorplot()
plt.title("Probe: " + meta["title"])
experiment.set_energy_labels(stepsize=0.1)
lines = []
for i, (mu0, sigma0) in enumerate(
sorted(meta["peaks"], key=lambda peak: peak[0]), 1):
fit = experiment.find_peak(mu0, sigma0, plot=plot)
mu = experiment.channel2energy(fit.mu)
error_mu_stat = experiment.channelwidth2energywidth(
fit.sigma_mu)
error_mu_sys = experiment.sigma_channel2energy(fit.mu)
string_mu = format_error(mu,
error_mu_stat,
error_mu_sys,
unit='keV')
sigma = experiment.channelwidth2energywidth(fit.sigma)
error_sigma_stat = experiment.channelwidth2energywidth(
fit.sigma_sigma)
#error_sigma_sys = experiment.sigma_channelwidth2energywidth(fit.sigma) # close to 0
string_sigma = format_error(sigma,
error_sigma_stat,
unit='keV')
lines.append(r"$E_" + str(i) + r"$ = " + string_mu)
peaktable.row((meta["title"], len(meta["peaks"])),
format_error(fit.A,
fit.sigma_A,
parenthesis=False), string_mu,
string_sigma)
if plot:
plt.title("Probe: " + meta["title"] + " - Peak %d" % i)
plt.xlim(fit.mu - 5 * fit.sigma, fit.mu + 5 * fit.sigma)
plt.autoscale(enable=True, axis='y')
l, u = plt.ylim()
plt.ylim(0, u)
plt.savefig("out/" + clean_filename(filename) +
"_peak_%d." % i + SAVETYPE)
if plot:
plt.title("Probe: " + meta["title"])
experiment.set_energy_labels(stepsize=5)
plt.xlim(0, 4096)
plt.autoscale(enable=True, axis='y')
text = "\n".join(lines)
info_box(text, location='tr')
plt.savefig("out/" + clean_filename(filename) + "_all." +
SAVETYPE)
def kalibration(plot=True):
print("##### CALIBRATION #####")
channels = []
channel_errors = []
energies = []
with LatexTable("out/calib_peaks.tex") as peaktable, LatexTable(
"out/calib_counts.tex") as counttable, LatexTable(
"out/calib_relamp.tex") as relamptable:
peaktable.header("El.",
"Höhe",
"Channel",
"Breite",
r'$\chi^2/\textrm{ndf}$',
"Linie",
"Energie",
lineafter=0)
peaktable.row("", "", r"$x_\textrm{max}$", r"$\Delta x$", "", "", "")
peaktable.hline()
relamptable.header("Element",
"Peak",
"Relative Höhe",
"Literaturwert",
lineafter=1)
counttable.header("Element", "Messdauer", "Ereignisse")
for filename, meta in kalib.items():
peaktable.hline()
relamptable.hline()
#print("="*10, filename, "="*10)
experiment = Experiment("data/" + filename, title=meta["title"])
counttable.row(
meta["element"],
r'$' + experiment.mcameta["Accumulation Time"] + r' \unit{s}$',
experiment.mcameta["Slow Count"])
if plot:
plt.clf()
experiment.errorplot()
plt.title(meta["title"])
lines = []
kalpha = None
for i, (mu0, sigma0, peak, energy, lrel) in enumerate(
sorted(meta["peaks"], key=lambda peak: peak[0]), 1):
fit = experiment.find_peak(mu0, sigma0, plot=plot)
channels.append(fit.mu)
channel_errors.append(fit.sigma_mu)
#channel_errors.append(fit.sigma) # FEHLER
energies.append(energy)
lines.append("Peak {:d}, Channel {:s}, Energy {:s}".format(
i, format_error(fit.mu, fit.sigma_mu),
format_error(energy, 0.01, unit='keV')))
if not kalpha:
kalpha = (fit.A, fit.sigma_A)
fehler = np.sqrt(
np.power(fit.sigma_A / kalpha[0], 2) +
np.power(fit.A / np.power(kalpha[0], 2) * kalpha[1], 2))
rel = format_error(fit.A / kalpha[0] * 100,
fehler * 100,
unit=r'\%')
if kalpha[0] == fit.A:
rel = r"100 \%"
#rel = _n(fit.A/kalpha[0]*100, precision=3) + r"\%"
lrel = _n(lrel, precision=3) + r"\%"
relamptable.row((meta["element"], len(meta["peaks"])),
r'$ ' + peak + r'$', rel, lrel)
peaktable.row((meta["element"], len(meta["peaks"])),
format_error(fit.A,
fit.sigma_A,
parenthesis=False),
format_error(fit.mu,
fit.sigma_mu,
parenthesis=False),
format_error(fit.sigma,
fit.sigma_sigma,
parenthesis=False),
"%.2f" % fit.chisqndf, r'$ ' + peak + r'$',
r'$ ' + ("%.2f" % energy) + r' \unit{keV}$')
if plot:
plt.xlim(fit.mu - 5 * fit.sigma, fit.mu + 5 * fit.sigma)
plt.autoscale(enable=True, axis='y')
plt.savefig("out/" + clean_filename(filename) +
"_peak_%d." % i + SAVETYPE)
if plot:
text = "\n".join(lines)
#info_box(text, location='tr')
plt.xlim(0, 4096)
plt.autoscale(enable=True, axis='y')
plt.savefig("out/" + clean_filename(filename) + "_all." +
SAVETYPE)
X = np.array(channels)
SX = np.array(channel_errors)
Y = np.array(energies)
SY = 0.01 # 1 eV
fit = linear_fit(X, Y, xerr=SX, yerr=SY)
if plot:
plt.clf()
plt.errorbar(X, Y, xerr=SX, yerr=SY, fmt=',')
fit.plot(np.min(X),
np.max(X),
box='tl',
units={
"slope": "keV / Channel",
"offset": "keV"
})
plt.xlabel(r"Channel")
plt.ylabel(r"$ E $ / keV")
plt.title(r"Kalibrationsgerade: Fit")
plt.savefig("out/calib_fit." + SAVETYPE)
plt.clf()
err = fit.combine_errors(X, SX, SY)
fit.plot_residuums(X, Y, err, box='bl', fmt=",")
plt.xlabel(r"Channel")
plt.ylabel(r"$ E $ / keV")
plt.title(r"Kalibrationsgerade: Residuen")
plt.savefig("out/calib_residuum." + SAVETYPE)
s = format_error(fit.slope * 1000,
fit.sigma_slope * 1000,
unit="eV / Kanal",
surroundmath=False)
o = format_error(fit.offset * 1000,
fit.sigma_offset * 1000,
unit="eV",
surroundmath=False)
with open('out/calib.tex', 'w') as file:
file.write(
r'Die in diesem Versuch verwendeten Einstellungen f\"uhren zu einer Einteilung von \[ '
+ s + r' \] wobei der erste Kanal die Energie \[ ' + o +
r' \] besitzt.')
# print("RESULT: linear fit with chisq: %.2f" % (fit.chisqndf))
# print("RESULT: energy per bin: %.1f keV" % (fit.slope))
# print("RESULT: energy of 0th bin: %.1f keV" % (fit.offset))
return fit
