def signal_double_efficiencies(prefix, prefix_signal, verbose=0):
effmatrix = []
errmatrix = []
dt_type = 's'
tag = 'd'
mode_pair_list = attr.PossibleDoubleTags
for i in mode_pair_list:
txtfile = tools.set_file('txt',
dt_type,
i,
tag,
prefix=prefix_signal,
extbase=attr.fitpath)
N = float(DHadTable(txtfile).cell_get(1, 'Value'))
N_err = float(DHadTable(txtfile).cell_get(1, 'Error'))
tot_gen = get_generated_numbers_double(i, prefix_signal)
effline = []
errline = []
for j in mode_pair_list:
if i == j:
if '281ipbv0.1' in prefix and i == (1, 1):
tot_gen = tot_gen * (0.257402179684 / 0.140119760479)
eff = N / tot_gen
err = N_err / tot_gen * math.sqrt(1 - eff)
else:
eff = 0
err = 0
effline.append(eff)
errline.append(err)
effmatrix.append(effline)
errmatrix.append(errline)
eff_file_name = 'signal_double_efficiencies_for_werner'
err_file_name = 'signal_double_efficiencies_errors_for_werner'
eff_file = tools.set_file(extbase=attr.brfpath,
prefix=prefix,
comname=eff_file_name)
err_file = tools.set_file(extbase=attr.brfpath,
prefix=prefix,
comname=err_file_name)
output_matrix(effmatrix, eff_file)
output_matrix(errmatrix, err_file)
def events(args):
parsed = yld.parse_args(args)
datatype = parsed[0]
tag = parsed[1]
modes = parsed[2]
label_A = parsed[3]
label_B = args[3]
datpath = attr.datpath
tab = DHadTable()
tab.row_append(['Mode', label_A, label_B, 'Common',
'Unique(%s)' %label_A, 'Unique(%s)' %label_B ])
tab.head = tab.data[0]
for mode in modes:
modename = mode.replace('Single_', '')
evtname = datatype + '_' + mode + '.evt'
evtpath_A = os.path.join(datpath, 'evt', label_A, 'events')
evtfile_A = os.path.join(evtpath_A, evtname)
f_A = UserFile(evtfile_A)
events_A = Set(f_A.data)
evtpath_B = os.path.join(datpath, 'evt', label_B, 'events')
evtfile_B = os.path.join(evtpath_B, evtname)
f_B = UserFile(evtfile_B)
events_B = Set(f_B.data)
events_inter = events_A & events_B
entries_A = len(events_A)
entries_B = len(events_B)
common = len(events_inter)
unique_A = len(events_A - events_inter)
unique_B = len(events_B - events_inter)
row = [modename, entries_A, entries_B, common, unique_A, unique_B]
tab.row_append(map(str, row))
tab.output(_tabname)
def ratios_signal(args):
if args[0] == '537ipb/281ipb' and args[1] == '537ipbv2/281ipb':
tabfilename1 = 'compare_yields_signal_divide_537ipb_9.03_regular12.txt'
title1 = args[0]
headname1 = title1
tabfilename2 = 'compare_yields_signal_divide_537ipbv2_9.03_regular12.txt'
title2 = args[1]
headname2 = title2
else:
raise NameError(args)
tabfile1 = os.path.join(attr.tabpath, tabfilename1)
tabfile2 = os.path.join(attr.tabpath, tabfilename2)
if opts.set and opts.set == 'info':
print 'here'
tab = DHadTable()
tab.column_append_from_tab_file('Mode', tabfile1, 'Mode')
tab.column_append_from_tab_file(title1, tabfile1, headname1)
tab.column_append_from_tab_file(title2, tabfile2, headname2)
tab.column_append_by_diff_sigma_pct('diff(%)', title2, title1)
tab.output(_tabname)
def md(opts, tabname, args):
para = 'md'
namestyle = 'fname'
rnd = '0.0000001'
tag = 's'
if opts.set:
for li in opts.set.split(';'):
name = li.split('=')[0]
value = li.split('=')[1]
sys.stdout.write('Set %s = %s \n' % (name, value))
if name == 'label':
label = value
if args[0] == '281ipb':
tab_A_name = args[1]
tab_B_name = args[2]
tab_C_name = args[3]
if label:
labels = label.split(',')
tab_A_name = labels[0]
tab_B_name = labels[1]
tab_C_name = labels[2]
tab = DHadTable()
tab.column_append_from_dict('Mode', namestyle)
tab.column_append_from_fit_files(tab_A_name, args[1], para, tag, rnd)
tab.column_append_from_fit_files(tab_B_name, args[2], para, tag, rnd)
tab.column_append_from_fit_files(tab_C_name, args[3], para, tag, rnd)
tab.output(_tabname)
else:
raise ValueError(args)
def momentum(opts, tabname, args):
if args[0] != 'resolution':
raise NameError(args)
label = args[1]
dt_type = 'signal'
tag = 'double'
#ver = opts.analysis
fitbase = attr.fitpath
prefix = 'dir_%s/resolution' % label
# Mode | sigma(MeV) | fa | fb | sa | sb | [sigmaE (MeV)]
tab = DHadTable()
tab.column_append_from_dict('Mode', 'fname')
tab.column_append_from_files(
'sigma (MeV)', 'sigmacommon1', fitbase, prefix,
dt_type, tag, 'txt', rnd='.01', factor=1000)
tab.column_append_from_files('fa', 'f1a', fitbase, prefix,
dt_type, tag, 'txt', rnd='.001')
tab.column_append_from_files('fb', 'f1b', fitbase, prefix,
dt_type, tag, 'txt', rnd='.0001')
tab.column_append_from_files('sa', 's1a', fitbase, prefix,
dt_type, tag, 'txt', rnd='.01')
tab.column_append_from_files('sb', 's1b', fitbase, prefix,
dt_type, tag, 'txt', rnd='.01')
tab.output(tabname, test=opts.test)
def vary_argus_single(opts, tabname, label):
tab = DHadTable()
print tabname
tabprefix0 = 'dir_818ipbv7/argus_low/fix_n1n2'
tabprefix1 = 'dir_818ipbv7'
tabprefix2 = 'dir_818ipbv7/argus_high/fix_n1n2'
tab.column_append_from_dict('Mode', 'fname,fnamebar')
titles = ['argus_low', 'std', 'argus_high']
tab.column_append_from_files(titles[0], 'N1,N2', fitbase, tabprefix0, 'd',
's', 'txt')
tab.column_append_from_files(titles[1], 'N1,N2', fitbase, tabprefix1, 'd',
's', 'txt')
tab.column_append_from_files(titles[2], 'N1,N2', fitbase, tabprefix2, 'd',
's', 'txt')
std = titles[1]
colA = titles[0]
colB = titles[2]
headA = 'diff(%s)' % colA
headB = 'diff(%s)' % colB
headC = 'max-diff(%)'
tab.column_append_by_diff_pct(headA, colA, std)
tab.column_append_by_diff_pct(headB, colB, std)
tab.column_append_by_max(headC, headA, headB)
#tab.columns_delete([headA, headB])
tab.columns_trim(titles, rnd='1.')
tab.output() #tabname, texhead, outputtxt=True)
def mctruth_names_single_mode(datatype,
mode,
label,
limit,
mctruthmodes,
debug,
prefix=None):
var = 'mctruth'
mctruthfile = get_evtfile(datatype, mode, label, var)
if debug:
sys.stdout.write('\ndebug: mctruthfile %s\n' % mctruthfile)
tab = DHadTable(mctruthfile, evalcell=True)
tab.sort_by_column('Number', reverse=True)
if limit != None:
mcddbars = tab.column_get('Mode', 'Number' + limit)[1:]
if mctruthmodes != None:
mcddbars = tab.column_get('Mode')[1:mctruthmodes + 1]
numbers = tab.column_get('Number')[1:len(mcddbars) + 1]
mcddbarmodenames = mcddbars_to_modenames(mcddbars)
return mcddbarmodenames, numbers
def para_md(args):
para = 'md'
namestyle = 'fname'
rnd = '0.0000001'
tag = 's'
tab_A = args[0]
tab_B = args[1]
latel_A = tab_A
latel_B = tab_B
label = tools.parseopts_set(opts.set, 'label')
if label:
labels = label.split(',')
label_A = labels[0]
label_B = labels[1]
tab = DHadTable()
tab.column_append_from_dict('Mode', namestyle)
tab.column_append_from_fit_files(label_A, tab_A, para, tag, rnd)
tab.column_append_from_fit_files(label_B, tab_B, para, tag, rnd)
tab.column_append_by_diff('diff[MeV]', label_B,label_A, rnd=rnd, factor=1000)
tab.output(_tabname)
def entries(args):
dt_type = args[0]
tag = args[1]
label_A = args[2]
label_B = args[3]
evtpath = attr.evtpath
rnd='.01'
err_type=None
label = None
diff = 'pct'
tab = DHadTable()
tab.row_append(['Mode', label_A, label_B])
tab.head = tab.data[0]
for mode in attr.modes:
for sign in [1, -1]:
evtfile_A = tools.set_file('evt', dt_type, mode, tag, sign=sign,
prefix='dir_'+label_A, extbase=evtpath)
evtfile_B = tools.set_file('evt', dt_type, mode, tag, sign=sign,
prefix='dir_'+label_B, extbase=evtpath)
entries_A = tools.count_lines(evtfile_A)
entries_B = tools.count_lines(evtfile_B)
if sign == 1:
modename = attr.modes[mode]['fname']
else:
modename = attr.modes[mode]['fnamebar']
row = [modename, entries_A, entries_B]
tab.row_append(map(str, row))
tab.column_append_by_diff_pct('diff(%)', label_B,label_A, rnd=rnd, err_type=err_type)
tab.output(_tabname)
def diff(args):
label= None
if opts.set:
for li in opts.set.split(':'):
name = li.split('=')[0]
value = li.split('=')[1]
sys.stdout.write('Set %s = %s \n' % (name, value))
if name == 'label':
label = value
if label:
labels = label.split(',')
label_A = labels[0]
label_B = labels[1]
tab_A = 'compare_%s.txt' % args[0]
tab_B = 'compare_%s.txt' % args[1]
tabfile_A = os.path.join(attr.tabpath, tab_A)
tabfile_B = os.path.join(attr.tabpath, tab_B)
tab = DHadTable()
tab.column_append_from_tab_file('Mode', tabfile_A, 'Mode')
tab.column_append_from_tab_file(label_A, tabfile_A, 'diff(%)')
tab.column_append_from_tab_file(label_B, tabfile_B, 'diff(%)')
tab.column_append_by_diff('diff', label_B,label_A)
tab.output(_tabname)
def para_argus(para, args):
namestyle = 'fname'
rnd = '0.01'
tag = 's'
rowName = para
extbase = attr.fitbase
ext = 'txt'
dt_type = args[0]
tab_A = args[1]
tab_B = args[2]
label_A = tab_A
label_B = tab_B
label = tools.parseopts_set(opts.set, 'label')
if label:
labels = label.split(',')
label_A = labels[0]
label_B = labels[1]
tab = DHadTable()
tab.column_append_from_dict('Mode', namestyle)
tab.column_append_from_files(label_A, rowName, extbase, 'dir_'+tab_A,
dt_type, tag, ext, rnd=rnd)
tab.column_append_from_files(label_B, rowName, extbase, 'dir_'+tab_B,
dt_type, tag, ext, rnd=rnd)
tab.column_append_by_diff_pct('diff(%)', label_B, label_A, rnd=rnd)
tab.output(_tabname)
def events(args):
parsed = yld.parse_args(args)
datatype = parsed[0]
tag = parsed[1]
modes = parsed[2]
label = parsed[3]
unique_evt_label = label
if _set and 'events' in _set:
unique_evt_label = _set.split('=')[1]
tab = DHadTable()
row = ['Mode']
row.extend(attr.datasets_281)
tab.row_append(row)
for mode in modes:
modename = mode.replace('Single_', '')
evtfile = get_unique_evtfile(datatype,
mode,
unique_evt_label,
debug=_debug)
f = EventsFile(evtfile)
row = map(str, f.datasets_sorted)
row.insert(0, modename)
tab.row_append(row)
tab.output(_tabname)
def parsefile(f, lowmass, highmass, indict):
x0 = lowmass
x1 = highmass
xc = (x0 + x1) / 2.
tab = DHadTable(f)
N1 = float(tab.cell_get('N1', 'Value'))
N2 = float(tab.cell_get('N2', 'Value'))
if N1 > 1000 or N2 > 1000:
return
indict['x'].append(xc)
indict['exl'].append(xc - x0)
indict['exh'].append(x1 - xc)
N = N1 + N2
err_low_N1 = float(tab.cell_get('N1', 'Low'))
err_low_N2 = float(tab.cell_get('N2', 'Low'))
err_low = (err_low_N1**2 + err_low_N2**2)**.5
err_high_N1 = float(tab.cell_get('N1', 'High'))
err_high_N2 = float(tab.cell_get('N2', 'High'))
err_high = (err_high_N1**2 + err_high_N2**2)**.5
yc = float(N)
yl = float(err_low)
yh = float(err_high)
indict['y'].append(yc)
indict['eyl'].append(yl)
indict['eyh'].append(yh)
def bkg_names_single_mode(datatype,
mode,
label,
limit,
bkgmodes,
debug,
prefix=None):
bkgname = '%s_%s.txt' % (datatype, mode)
if prefix != None:
bkgname = '%s_%s_%s.txt' % (prefix, datatype, mode)
bkgname = bkgname.replace('/', '_')
bkgfile = tools.set_file(extbase=attr.bkgpath(),
prefix='dir_' + label,
comname=bkgname)
if debug:
sys.stdout.write('\ndebug: bkgfile %s\n' % bkgfile)
tab = DHadTable(bkgfile, evalcell=True)
tab.sort_by_column('Number', reverse=True)
if limit != None:
mcddbars = tab.column_get('Mode', 'Number' + limit)[1:]
if bkgmodes != None:
mcddbars = tab.column_get('Mode')[1:bkgmodes + 1]
numbers = tab.column_get('Number')[1:len(mcddbars) + 1]
mcddbarmodenames = mcddbars_to_modenames(mcddbars)
return mcddbarmodenames, numbers
def files(args):
if args[0].startswith('/'):
dira = args[0]
else:
dira = os.path.join(attr.base, args[0])
if args[1].startswith('/'):
dirb = args[1]
else:
dirb = os.path.join(attr.base, args[1])
d = filecmp.dircmp(dira, dirb)
sys.stdout.write('There are %s different files. \n' % len(d.diff_files))
tab = DHadTable()
tab.row_append(['FileName', 'A', 'B'])
for f in d.diff_files:
filea = os.path.join(dira, f)
fileb = os.path.join(dirb, f)
tab.row_append_from_files(f, [filea, fileb])
tab.output_org()
def get_generated_numbers_single(i, prefix=''):
if '281ipb' in prefix:
mult_fact = 10
elif '537ipb' in prefix:
mult_fact = 20
elif '818ipb' in prefix or 'v13' in prefix:
mult_fact = 30
else:
raise NameError(prefix)
mode = i[0]
sign = i[1]
tag_number = modes[mode]['tag_num_s']
count = tag_number * mult_fact
if mode == 205:
if sign == 1:
count = 29972 # 30000
if sign == -1:
count = 35969 # 36000
if 'noFSR' in prefix:
mode = i[0]
sign = i[1]
logfile = tools.set_file('log',
's',
mode,
's',
sign,
prefix,
extbase=evtlogbase)
tab = DHadTable(logfile)
FSR = tab.cell_get('FSR', 'Value')
count = count - int(FSR)
return count
def get_generated_numbers_double(pair, prefix=''):
if '281ipb' in prefix:
mult_fact = 10
elif '537ipb' in prefix:
mult_fact = 20
elif '818ipb' in prefix or 'v13' in prefix:
mult_fact = 30
else:
raise NameError(prefix)
i = pair[0]
j = pair[1]
#genpath = attr.genpath
#print genpath
#sys.exit()
#if attr.analysis == '10.1' and '281ipbv0' in prefix :
# genpath = '/nfs/cor/user/ponyisi/cleog/scripts-summerconf/'
tag_number = 2000
count = tag_number * mult_fact
if 'v13' in prefix:
fname = modes[i]['fname']
fnamebar = modes[j]['fnamebar']
modename = 'Double_%s__%s' % (fname, fnamebar)
if modename == 'Double_Dp_to_KKpi__Dm_to_KKpi':
count = 47966
if modename == 'Double_Dp_to_KKpi__Dm_to_Kpipipi0':
count = 58403
if modename == 'Double_Dp_to_KKpi__Dm_to_Kpipi':
count = 57954
if modename == 'Double_Dp_to_KKpi__Dm_to_Kspipi0':
count = 57969
if modename == 'Double_Dp_to_KKpi__Dm_to_Kspipipi':
count = 24693
if modename == 'Double_Dp_to_KKpi__Dm_to_Kspi':
count = 57953
if modename == 'Double_Dp_to_Kpipi__Dm_to_KKpi':
count = 59952
if modename == 'Double_Dp_to_Kpipipi0__Dm_to_KKpi':
count = 55955
if modename == 'Double_Dp_to_Kspi__Dm_to_KKpi':
count = 57954
if modename == 'Double_Dp_to_Kspipi0__Dm_to_KKpi':
count = 57956
if modename == 'Double_Dp_to_Kspipipi__Dm_to_KKpi':
count = 57954
if 'noFSR' in prefix:
logfile = tools.set_file('log',
's',
pair,
'd',
prefix=prefix,
extbase=evtlogbase)
tab = DHadTable(logfile)
FSR = tab.cell_get('FSR', 'Value')
count = count - int(FSR)
return count
def create_fig_mode(tag, dt_type, mode, label):
if tag == 'single':
modename = attr.modes[mode]['orgname']
else:
if mode == 'double_all_d0s':
modename = 'Double all D0s'
elif mode == 'double_all_dps':
modename = 'Double all Dps'
else:
mode1 = mode[0]
mode2 = mode[1]
modename = '%s, %s' % (attr.modes[mode1]['orgname'],
attr.modes[mode2]['orgnamebar'])
prefix = 'dir_' + label
epsfile = tools.set_file('eps',
dt_type,
mode,
tag,
prefix=prefix,
extbase=attr.figpath)
head, tail = os.path.split(epsfile)
comname = tail.replace('.eps', '')
figlabel = label.split('/')[0]
relpath = label.replace(figlabel, '')
pdflink = '.%s/%s.pdf' % (relpath, comname)
pnglink = '.%s/%s.png' % (relpath, comname)
loglink = '[[../../log/%s/%s.txt][log]]' % (label, comname)
figlink = '[[%s][%s]]' % (pdflink, pnglink)
fitpath = attr.fitpath
tabfile = tools.set_file('txt',
dt_type,
mode,
tag,
prefix=prefix,
extbase=fitpath)
if os.access(tabfile, os.F_OK):
orgtabfile = tools.set_file('org',
dt_type,
mode,
tag,
prefix=prefix,
extbase=fitpath)
tab = DHadTable(tabfile)
tab.output_org(orgtabfile)
abspath = os.path.join(attr.base) #, attr.analysis)
orgtabfile = orgtabfile.replace(abspath, '../..')
tablink = '#+INCLUDE: "%s"\n' % orgtabfile
msg = '\n* %s \n %s \n\n%s\n %s\n' % (modename, figlink, tablink,
loglink)
else:
sys.stdout.write('File does not exist: %s \n' % tabfile)
sys.stdout.write('Skipping mode %s ... \n' % str(mode))
msg = '\n* %s \n Skipped.\n' % modename
return msg
def bkg_generic_cont(tabname, datatype, tag, modes, label, test, debug):
tab = DHadTable()
row = ['Mode', 'Continuum Backgrounds']
tab.row_append(row)
for mode in modes:
new_row = bkg_cont_single_mode(datatype, mode, label, debug)
tab.row_append(new_row)
tab.output(tabname, test=test)
def make_overview_table(tabname, datatype, modes, label, test=False):
tab = DHadTable()
tab.row_append(['Mode', 'Backgrounds'])
for mode in modes:
modename = mode.replace('Single_', '')
bkgtable = get_bkg_tab_link(datatype, mode, label)
line = [modename, bkgtable]
tab.row_append(line)
tab.output(tabname, test=test)
def evt(opts, args):
tabname = 'entries_evt_' + '_'.join(args).replace('/', '_')
if args[0] == 'log':
return evt_log(args[1:])
if args[0] not in ['data']:
raise NameError(args)
dt_type = args[0]
tag = args[1]
label = args[2]
evtpath = attr.evtpath()
if '/' in label:
ver = label.split('/')[0]
label = label.split('/')[1]
evtpath = attr.evtpath(ver)
prefix = 'dir_' + label
tab = DHadTable()
tab.row_append(['Mode', 'fname', 'fnamebar', 'combined', 'sum(theory)'])
for mode in attr.modes:
evtfile1 = tools.set_file('evt',
dt_type,
mode,
tag,
sign=-1,
prefix=prefix,
extbase=evtpath)
evtfile2 = tools.set_file('evt',
dt_type,
mode,
tag,
sign=1,
prefix=prefix,
extbase=evtpath)
evtfile_combined = tools.set_file('evt',
dt_type,
mode,
tag,
prefix=prefix,
extbase=evtpath)
entries1 = tools.count_lines(evtfile1)
entries2 = tools.count_lines(evtfile2)
sumup = entries1 + entries2
entries_combined = tools.count_lines(evtfile_combined)
row = [mode, entries1, entries2, entries_combined, sumup]
tab.row_append(map(str, row))
tab.output(tabname)
def get_fsr_sys(label):
if label == '281ipbv12.0':
tabfile = os.path.join(attr.tabpath, '281ipbv0', 'FSR_syst.txt')
tab = DHadTable(tabfile)
print 'Loading %s ...' % tabfile
fsr_sys = tab.column_get('diff X 30%')
else:
tab = get_mode_dependent_syst_tab(label)
fsr_sys = tab.row_get('FSR')
return fsr_sys
def yields(opts, tabname, args):
if args[0] not in ['signal', 'data'] :
raise NameError(args)
rnd='.01'
err_type=None
diff = 'pct'
sign = 1
if opts.set:
for li in opts.set.split(':'):
name = li.split('=')[0]
value = li.split('=')[1]
sys.stdout.write('Set %s = %s \n' % (name, value))
if name == 'diff':
diff = value
if name == 'err_type':
err_type = value
if name == 'sign':
sign = value
variable = 'yields'
dt_type = args[0]
tag = args[1]
label_A = args[2]
label_B = args[3]
fitbase = attr.fitbase
sys.stdout.write('dhad.tab : Compare %s between %s and %s:\n' %(
variable, label_A, label_B ))
tab = DHadTable()
namestyle = 'fname,fnamebar'
tab.column_append_from_dict('Mode', namestyle)
tab.column_append_from_files(label_A, 'N1,N2', fitbase, 'dir_%s' %label_A,
dt_type, tag ,'txt', rnd='1.')
tab.column_append_from_files(label_B, 'N1,N2', fitbase, 'dir_%s' %label_B,
dt_type, tag ,'txt', rnd='1.')
if sign == '0':
tab.rows_join_by_average(rnd='1.')
if diff == 'pct':
tab.column_append_by_diff_pct(
'diff(%)', label_B,label_A, rnd=rnd, err_type=err_type)
elif diff == 'sigma_pct':
tab.column_append_by_diff_sigma_pct('diff(%)', label_B,label_A, rnd=rnd)
elif diff == 'sigma2_pct':
tab.column_append_by_diff_sigma2_pct('diff(%)', label_B,label_A, rnd=rnd)
elif diff == 'ratio':
tab.column_append_by_divide(
'ratio', label_B,label_A, rnd=rnd, err_type='Indp')
else:
raise NameError(diff)
tab.output(tabname, test=opts.test)
def para_momentum_resolution():
if tools.valid_version('10.1.5'):
tabnameA = 'line_shape_paras'
tabnameB = 'para_momentum_resolution'
else:
raise NameError(attr.src)
tabfileA = tools.set_file(extbase=attr.tabpath,
comname=tabnameA, ext='txt')
tabfileB = tools.set_file(extbase=attr.tabpath,
comname=tabnameB, ext='txt')
tabA = DHadTable(tabfileA)
tabB = DHadTable(tabfileB)
tab = tabA.diff_sigma_pct(tabB)
tab.output(_tabname)
def brf_data_results(opts, tabname, args):
'''
-----------------------------
Results of the Data Fit
-----------------------------
'''
label_A = args[0]
label_B = args[1]
verbose = opts.verbose
bffilename = 'bf_stat_sys'
labels = []
labels.append(label_A)
labels.append(label_B)
tab = DHadTable()
paras = False
for label in labels:
if '281ipb' in label:
factor = 0.000001
elif '537ipb' in label:
factor = 0.000001*281/537
elif '818ipb' in label or 'v13' in label:
factor = 0.000001*281/818
else:
raise NameError(label)
if '818ipb' in label_A and '818ipb' in label_B:
factor = 0.000001
if '818ipb' in label_A and 'v13' in label_B:
factor = 0.000001
bffile = os.path.join(attr.brfpath, label, bffilename)
if not paras:
tab.column_append(tools.parse_result(bffile, 'paras'),
'Parameters')
paras = True
tab.column_append(tools.parse_result(bffile, 'value'), 'value', rnd='.00001' )
tab.column_append(tools.parse_result(bffile, 'stat'), 'stat')
tab.column_append(tools.parse_result(bffile, 'syst'), 'syst')
tab.columns_join3('Fitted Value', 'value', 'stat', 'syst')
tab.column_trim('Fitted Value', row=['ND0D0Bar', 'ND+D-'],
rnd='.0001', factor=factor, opt='(cell)x1E6')
tab.column_trim('Fitted Value', rnd='.00001',
except_row=['ND0D0Bar', 'ND+D-'])
tab.column_append(tools.parse_result(bffile, 'err_frac'),
'Frac. Err', rnd='.1', opt='(cell%)')
tab.columns_join(label, 'Fitted Value','Frac. Err', str=' ')
tab.column_append_by_diff_sigma('Difference', label_B,label_A)
tab.output(tabname, test=opts.test)
def get_signal_shape_sys(label):
if label == '281ipbv12.0':
tabfile = os.path.join(attr.tabpath, '281ipbv0',
'signal_line_shape_syst.txt')
print 'Loading %s ...' % tabfile
tab = DHadTable(tabfile)
line_shape_sys = tab.column_get('Total(%)')
else:
tab = get_mode_dependent_syst_tab(label)
line_shape_sys = tab.row_get('Signal shape')
return line_shape_sys
def mctruth_ddbar_single_mode(datatype, mode, label, ranges, test):
var = 'mctruth'
mctruthfile = get_evtfile(datatype, mode, label, var)
if test:
sys.stdout.write('\ntest: mctruthfile %s\n' % mctruthfile)
modename = mode.replace('Single_', '')
mctruthtable = get_mctruth_tab_link(datatype, mode, label)
result = [modename, mctruthtable]
tab = DHadTable(mctruthfile)
result.extend(tab.column_analyze('Number', ranges))
return result
def bkg_generic_ddbar(tabname, datatype, tag, modes, label, test, debug):
ranges = ['>0', '>50', '>100', '>200', '>500', '>1000', '>2000', '>3000']
tab = DHadTable()
row = ['Mode', 'Backgrounds']
row.extend(ranges)
tab.row_append(row)
for mode in modes:
new_row = bkg_ddbar_single_mode(datatype, mode, label, ranges, debug)
tab.row_append(new_row)
tab.output(tabname, test=test)
def fitResultsMC(opts, tabname, label):
bffilename = 'bf_stat'
bffile = tools.set_file(extbase=attr.brfpath,
prefix='dir_' + label,
comname=bffilename)
if '281ipbv0' in label and '/generic' in label:
generated = attr.Generic281v0_NBF
power = '10E6'
factor = 0.000001
elif '281ipbv12' in label and '/generic' in label:
generated = attr.Generic281_NBF
power = '10E7'
factor = 0.0000001
elif '818ipbv12' in label and '/generic' in label:
generated = attr.Generic818_NBF
power = '10E7'
factor = 0.0000001
else:
raise NameError(label)
tab = DHadTable()
tab.column_append(parse_result(bffile, 'paras'), 'Parameters')
tab.column_append(parse_result(bffile, 'value_err'), 'Fitted Value')
tab.column_append(generated, 'Generated Value')
tab.column_append_by_diff_sigma('Difference', 'Fitted Value',
'Generated Value')
tab.column_trim('Fitted Value',
row=['ND0D0Bar', 'ND+D-'],
rnd='.001',
factor=factor,
opt='(cell)x%s' % power)
tab.column_trim('Fitted Value',
rnd='.00001',
except_row=['ND0D0Bar', 'ND+D-'])
tab.column_append(parse_result(bffile, 'err_frac'),
'Frac. Err',
rnd='.1',
opt='(cell%)')
tab.columns_join('Fitted Value', 'Fitted Value', 'Frac. Err', str=' ')
tab.column_trim('Generated Value',
row=['ND0D0Bar', 'ND+D-'],
rnd='.001',
factor=factor,
opt='cellx%s' % power)
tab.output(tabname, label=label)
def eff_kkpi_comp(opts, tabname, label):
tab = DHadTable()
tabprefix = 'dir_' + label
mode = 205
tab.column_append_from_dict('Mode', 'fname,fnamebar', mode=mode)
tab.column_append([20000, 20000], 'Generated')
tab.column_append_from_files('Yield',
'N1,N2',
fitbase,
tabprefix,
's',
's',
'txt',
rnd='1.',
mode=mode)
tab.column_append_by_divide('Eff(%)', 'Yield', 'Generated', 'Efcy', '.01',
100)
tab.columns_delete(['Generated', 'Yield'])
def get_eff(subdir):
logname = 'signal_Single_%s.txt' % modes[mode]['fname']
logpath = os.path.join(attr.logpath, label, subdir, 'yld')
logfile = tools.set_file(extbase=logpath, comname=logname)
for line in file(logfile):
if 'selected' in line:
total = int(line.split()[-1].replace('.', ''))
break
t = DHadTable()
t.column_append([total, total], 'Generated')
t.column_append_from_files('Yield',
'N1,N2',
fitbase,
'%s/%s' % (tabprefix, subdir),
's',
's',
'txt',
rnd='1.',
mode=mode)
t.column_append_by_divide('%s(%%)' % subdir, 'Yield', 'Generated',
'Efcy', '.01', 100)
return t.column_get('%s(%%)' % subdir)
for subdir in ['phipi', 'k0star', 'phsp']:
tab.column_append(get_eff(subdir))
#head_diff = subdir
#col = '%s(%%)' % subdir
#std = 'Eff(%)'
#tab.column_append_by_diff_pct(head_diff, col, std)
tab.output(tabname, label=label)
