def add_axes(axes):
for name, details in axes.items():
if details.get('binning') is not None:
cw.add_axis_with_binning(name,details['value'],details['binning']['type'],
details['binning']['low'],details['binning']['high'],details['binning']['nbins'])
else:
cw.add_axis(name,details['value'])
def add_gauss_constraints(gauss_constraints):
for name, details in gauss_constraints.items():
array_ids=details['observable_ids']['array_ids']
mu=details['mu']
sigmas=details['sigmas']
function_name=details['function_name']
cw.add_gauss_constraint(name,array_ids,mu,sigmas,function_name)
contour_constraints=populate_with_array_ids((user.contour_constraints.get()),style,array_ids_dict)
# populate contours and add to managers
contours=populate_contours(user.contours.get())
add_contours(contours)
# now add values to the managers
add_vars_lookups(vars_lookups)
add_vars_functions(vars_functions)
add_gauss_constraints(gauss_constraints)
add_contour_constraints(contour_constraints)
format='{:<30}: {:30}'
number_format='{:<30}: {:<5.3f}'
if args.observables:
observables=user.observables.get(args.observables)
print('='*50)
for observable in observables:
value=ctw.get_value(observable,vars)
print(number_format.format(observable,value))
if args.breakdown:
# look for chi2 calculators
constraints=user.constraints_sets.get(args.breakdown)
add_chi2_calculator(args.breakdown,constraints)
print('='*50)
print(format.format('constraint','chi2'))
print('='*50)
for constraint in constraints:
chi2=ctw.get_value(constraint,vars)
constraint=constraint.replace('chi2-','')
print(number_format.format(constraint,chi2))
print('='*50)
print(number_format.format('total',ctw.get_value(args.breakdown,vars)))
print('='*50)
mneu_mg_m12g_m3g_X2_lookup=user.mneu_mg_m12g_m3g_X2_lookups.get().get(name)
if gauss_constraint is not None:
gauss_constraint=add_array_ids(gauss_constraint,style)
tools.add_gauss_constraints({name:gauss_constraint})
elif contour_constraint is not None:
contours=tools.populate_contours(user.contours.get())
tools.add_contours(contours)
contour_constraint=add_array_ids(contour_constraint,style)
tools.add_contour_constraints({name:contour_constraint})
elif mneu_mg_m12g_m3g_X2_lookup is not None:
mneu_mg_m12g_m3g_X2_lookup=add_array_ids(mneu_mg_m12g_m3g_X2_lookup,style)
lookups={name:mneu_mg_m12g_m3g_X2_lookup}
lookups=tools.populate_mneu_mg_m12g_m3g_X2_lookups(lookups)
tools.add_mneu_mg_m12g_m3g_X2_lookups(lookups)
else:
print('{} not found in gauss or contour constraints.\Exiting'.format(name))
exit()
if __name__=='__main__':
args=parse_args()
if args.print_all_gauss_constraints:
pp(list(user.gauss_constraints.get().keys()))
name=args.constraint
if not 'chi2-' in name:
print('adding prefix chi2- to the name of the constraint')
name='chi2-{}'.format(name)
setup_constraint(name,args.style)
vars=args.values
value=cw.get_value(name,vars)
print('{:<20} :{}'.format(name,value))
if __name__ == '__main__':
#get arguments
args=parse_args()
input_name=args.db_in
output_name=args.db_out
max_chi2=args.max_chi2
chi2_function_name=args.reference
# create mcpp_observable_ids in new database
create_mcpp_observable_ids(input_name,output_name)
# get array ids
array_ids_dict, style=get_array_ids_and_style(input_name)
# populate vars_lookups, vars_functions, and gauss_constraints with array ids
gauss_constraints=tools.populate_with_array_ids((user.gauss_constraints.get()),style,array_ids_dict)
contour_constraints=tools.populate_with_array_ids((user.contour_constraints.get()),style,array_ids_dict)
# populate contours and add to managers
contours=tools.populate_contours(user.contours.get())
tools.add_contours(contours)
# now add values to the managers
tools.add_gauss_constraints(gauss_constraints)
tools.add_contour_constraints(contour_constraints)
# look for chi2 calculators
if args.reference in user.constraints_sets.constraints.keys():
tools.add_chi2_calculator(args.reference,user.constraints_sets.get(args.reference))
# make selection query
sql_where=''
if args.sql_where is not None:
sql_where='where ' + args.sql_where
select_query='select rowid, * from points {};'.format(sql_where)
#finally make the plots
cw.sqlite_reduce_db(input_name,output_name,select_query,chi2_function_name,max_chi2)
def add_contours(contours):
for name, details in contours.items():
cw.add_contour(name,details['xs'],details['ys'],details['type'])
def add_spaces(spaces):
for space in spaces:
axes=space['axes']
zaxes=space.get('zaxes',[])
reference=space['reference_value']
cw.add_space(axes,zaxes,reference)
sql_selection='select {} from points {};'.format(columns,sql_where)
print('the sql query is:\n{}'.format(sql_selection))
# get unique items in the list ordered
vars_lookups=tools.populate_with_array_ids(vars_lookups,style,array_ids_dict)
vars_functions=tools.populate_with_array_ids(vars_functions,style,array_ids_dict)
gauss_constraints=tools.populate_with_array_ids(gauss_constraints,style,array_ids_dict)
contour_constraints=tools.populate_with_array_ids(contour_constraints,style,array_ids_dict)
mneu_mg_m12g_m3g_X2_lookups=tools.populate_with_array_ids(mneu_mg_m12g_m3g_X2_lookups,style,array_ids_dict)
# pupulate mneu_mg_m12g_m3g_X2_lookups with the lookup data
mneu_mg_m12g_m3g_X2_lookups=tools.populate_mneu_mg_m12g_m3g_X2_lookups(mneu_mg_m12g_m3g_X2_lookups)
# populate contours and add to managers
contours=tools.populate_contours(user.contours.get())
tools.add_contours(contours)
# now add values to the managers
tools.add_vars_lookups(vars_lookups)
tools.add_vars_functions(vars_functions)
tools.add_gauss_constraints(gauss_constraints)
tools.add_contour_constraints(contour_constraints)
tools.add_mneu_mg_m12g_m3g_X2_lookups(mneu_mg_m12g_m3g_X2_lookups)
# look for chi2 calculators
if args.reference in user.constraints_sets.constraints.keys():
tools.add_chi2_calculator(args.reference,user.constraints_sets.get(args.reference))
# axes and spaces to managers
tools.add_axes(axes)
tools.pp(spaces)
tools.add_spaces(spaces)
# input and output files
outfile=args.outfile
#finally make the plots
cw.sqlite_make_plots(args.sqlite_db,sql_selection,outfile,args.reference)
axes.set_xticks(numpy.arange(low,high*1.001,step))
if axes_details[1].get('yticks',False) and binnings[1]['type']=='linear':
low,high,step=binnings[1]['low'],binnings[1]['high'],axes_details[1]['yticks']
axes.set_yticks(numpy.arange(low,high*1.001,step))
text_box_options_list = figure_options.get('text_boxes',False)
if isinstance(text_box_options_list, list):
for text_box_options in text_box_options_list:
args=text_box_options.get('args')
kwargs={'verticalalignment':'top','transform':axes.transAxes,
'fontsize':20,'horizontalalignment':'left'}
kwargs.update(text_box_options.get('kwargs',{}))
axes.text(*args,**kwargs)
#FIXME: there might be a better way of zipping an unzipping
filenames, plotnames, layers_options, layers_zaxis = layers_details
for filename, plotname, layer_options, layer_zaxis in zip(filenames, plotnames, layers_options, layers_zaxis):
plot=cw.get_2d_hist(filename,plotname,nxbins,nybins)
entries_plotname='{}_entries'.format('_'.join([axis['name'] for axis in axes_details]))
entries_plot=cw.get_2d_hist(filename,entries_plotname,nxbins,nybins)
chi2_plotname='{}_chi2'.format('_'.join([axis['name'] for axis in axes_details]))
chi2_plot=cw.get_2d_hist(filename,chi2_plotname,nxbins,nybins)
if layer_options.get('colz',False):
#mask where rowid == -1 (not filled)
plot=ma.masked_where(entries_plot==-1,plot)
if layer_options.get('mask_dchi2_gt'):
dchi2_max=layer_options.get('mask_dchi2_gt')
chi2_minimum=cw.get_min_reference(filename)
if chi2_minimum==1e9:
chi2_minimum=layer_options.get('chi2_minimum',numpy.min(chi2_plot))
plot=ma.masked_where(chi2_plot>chi2_minimum+dchi2_max,plot)
if layer_options.get('dchi2_mode',False):
chi2_minimum=cw.get_min_reference(filename)
def add_mneu_mg_m12g_m3g_X2_lookups(lookups):
for name, details in lookups.items():
array_ids=details['observable_ids']['array_ids']
default_X2=details['default_X2']
mneu_mg_m12g_m3g_X2_table=details['table']
cw.add_mneu_mg_m12g_m3g_X2_lookup(name,array_ids,default_X2,mneu_mg_m12g_m3g_X2_table)
def add_contour_constraints(contour_constraints):
for name, details in contour_constraints.items():
array_ids=details['observable_ids']['array_ids']
contours=details['contours']
function_name=details['function']
cw.add_contour_constraint(name,array_ids,contours,function_name)
def add_cuts(cuts):
for name, details in cuts.items():
array_ids=details['observable_ids']['array_ids']
function_name=details['function']
cw.add_cut(name,array_ids,function_name)
def add_vars_functions(vars_functions):
for name, details in vars_functions.items():
array_ids=details['observable_ids']['array_ids']
function_name=details['name']
cw.add_vars_function(name,array_ids,function_name)
def add_vars_lookups(vars_lookups):
for name, details in vars_lookups.items():
array_id=details['observable_ids']['array_ids']
if isinstance(array_id,list):
array_id=array_id[0]
cw.add_vars_lookup(name,array_id)
bin_edges.append(numpy.linspace(low,high,nbins+1))
bin_centres.append(numpy.linspace(low+half_bin,high-half_bin,nbins))
elif b['type']=='log':
low,high,nbins=numpy.log10(b['low']), numpy.log10(b['high']), b['nbins']
half_bin=0.5*(high-low)/nbins
bin_edges.append(numpy.logspace(low,high,nbins+1))
bin_centres.append(numpy.logspace(low+half_bin,high-half_bin,nbins))
#plot settings
if binnings[0]['type'] == 'log':
plt.xscale('log')
plt.xlabel(axes[0])
nxbins=binnings[0]['nbins']
#get points
if len(axes)==1:
chi2_plot=cw.get_1d_hist(rootfile,'{}_chi2'.format(plotname),nxbins)
entries_plot=cw.get_1d_hist(rootfile,'{}_entries'.format(plotname),nxbins)
plt.plot(bin_centres[0],chi2_plot,'o')
plt.ylim([vmin,vmax])
if args.best_fit:
chi2_min=numpy.min(chi2_plot)
rowid=int(entries_plot[chi2_plot==numpy.min(chi2_plot)])
else:
[(x,y)]=plt.ginput(1)
id=numpy.where(bin_edges[0]>x)[0][0]-1
print('Clicked points: {}: {} {}: {}'.format(axes[0],x,'chi2',y))
rowid=int(entries_plot[id])
#get plots
elif len(axes)==2:
nybins=binnings[0]['nbins']
add_vars_functions(vars_functions)
add_gauss_constraints(gauss_constraints)
add_contour_constraints(contour_constraints)
add_mneu_mg_m12g_m3g_X2_lookups(mneu_mg_m12g_m3g_X2_lookups)
# add cuts to manager
add_cuts(cuts)
# look for chi2 calculators
if args.reference in user.constraints_sets.constraints.keys():
add_chi2_calculator(args.reference,user.constraints_sets.get(args.reference))
# look for cut sets
cuts_names=user.cuts_sets.get(args.cuts)
# axes and spaces to managers
add_axes(axes)
pp(spaces)
add_spaces(spaces)
# input and output files
outfile=args.outfile
if args.rootfiles is not None:
infiles=args.rootfiles
if (len(args.rootfiles)==1) and (outfile is None):
outfile=args.rootfiles[0]
elif args.files_dir_and_prefix is not None:
basedirs=args.files_dir_and_prefix[:-1]
prefix=args.files_dir_and_prefix[-1]
infiles=[]
print(basedirs)
for basedir in basedirs:
infiles+=get_all_but_the_last_root_files(basedir,prefix)
#finally make the plots
cw.make_plots(infiles,outfile,args.nentries,args.dir_in_root,cuts_names)
if not figure_options.get('suppress_ticks_from_axes',False):
if xaxis_details.get('xticks',False) and binning['type']=='linear':
low,high,step=binning['low'],binning['high'],xaxis_details['xticks']
axes.set_xticks(numpy.arange(low,high*1.001,step))
text_box_options_list = figure_options.get('text_boxes',False)
if isinstance(text_box_options_list, list):
for text_box_options in text_box_options_list:
args=text_box_options.get('args')
kwargs={'verticalalignment':'top','transform':axes.transAxes,
'fontsize':20,'horizontalalignment':'left'}
kwargs.update(text_box_options.get('kwargs',{}))
axes.text(*args,**kwargs)
#FIXME: there might be a better way of zipping an unzipping
filenames, plotnames, layers_options = layers_details
for filename, plotname, layer_options in zip(filenames, plotnames, layers_options):
plot=cw.get_1d_hist(filename,plotname,nxbins)
entries_plotname='{}_entries'.format(xaxis_details['name'])
entries_plot=cw.get_1d_hist(filename,entries_plotname,nxbins)
if layer_options.get('dchi2_mode',False):
#chi2_minimum=cw.get_min_reference(filename)
chi2_minimum = cw.get_1d_minimum(filename,plotname,nxbins)
if chi2_minimum==1e9:
chi2_minimum=layer_options.get('chi2_minimum',numpy.min(plot))
plot=plot-chi2_minimum
color=layer_options.get('color')
linestyle=layer_options.get('linestyle')
linewidth=layer_options.get('linewidth',2)
label = layer_options.get('label')
axes.plot(bin_centres,plot,linewidth=linewidth,c=color,
linestyle=linestyle)
#FIXME: maybe ylim shouldn't be a property of the layer
def add_chi2_calculator(name,constraints_list):
cw.add_chi2_calculator(name)
for constraint in constraints_list:
cw.add_constraint_to_chi2_calculator(constraint,name)
vars_functions=populate_with_array_ids(user.vars_functions.get(),style,array_ids_dict)
gauss_constraints=populate_with_array_ids((user.gauss_constraints.get()),style,array_ids_dict)
contour_constraints=populate_with_array_ids((user.contour_constraints.get()),style,array_ids_dict)
# populate contours and add to managers
contours=populate_contours(user.contours.get())
add_contours(contours)
# get axes that are in the spaces
axes_list=get_axes_list_from_spaces(spaces)
# for now the "valid" value functions are those for which array_ids are specified
valid_values_list=list(vars_lookups.keys())+list(vars_functions.keys())+ \
list(gauss_constraints.keys())+list(contour_constraints.keys())+\
[args.reference]
# populate the valid-and-required-by-spaces axes
axes=populate_axes(user.axes.get(),valid_values_list,axes_list)
# now add values to the managers
add_vars_lookups(vars_lookups)
add_vars_functions(vars_functions)
add_gauss_constraints(gauss_constraints)
add_contour_constraints(contour_constraints)
# look for chi2 calculators
if args.reference in user.constraints_sets.constraints.keys():
add_chi2_calculator(args.reference,user.constraints_sets.get(args.reference))
# axes and spaces to managers
add_axes(axes)
pp(spaces)
add_spaces(spaces)
# input and output files
outfile=args.outfile
#finally make the plots
cw.sqlite_make_plots(args.sqlite_db,'select rowid, * from points;',outfile)
def main(args):
db=args.sqlite_db
#establish lookup
array_ids_dict, style=get_array_ids_and_style(db)
vars,collection_rowid=get_vars_from_db(db,args.rowid)
# populate values as usual previously
# populate vars_lookups, vars_functions, and gauss_constraints with array ids
vars_lookups={name: {'observable_ids': oids} for name, oids in user.vars_lookups.get().items()}
vars_lookups=populate_with_array_ids(vars_lookups,style,array_ids_dict)
vars_functions=populate_with_array_ids(user.vars_functions.get(),style,array_ids_dict)
gauss_constraints=populate_with_array_ids((user.gauss_constraints.get()),style,array_ids_dict)
contour_constraints=populate_with_array_ids((user.contour_constraints.get()),style,array_ids_dict)
mneu_mg_m12g_m3g_X2_lookups=populate_with_array_ids((user.mneu_mg_m12g_m3g_X2_lookups.get()),style,array_ids_dict)
# pupulate mneu_mg_m12g_m3g_X2_lookups with the lookup data
mneu_mg_m12g_m3g_X2_lookups=populate_mneu_mg_m12g_m3g_X2_lookups(mneu_mg_m12g_m3g_X2_lookups)
# populate contours and add to managers
contours=populate_contours(user.contours.get())
add_contours(contours)
# now add values to the managers
add_vars_lookups(vars_lookups)
add_vars_functions(vars_functions)
add_gauss_constraints(gauss_constraints)
add_contour_constraints(contour_constraints)
add_mneu_mg_m12g_m3g_X2_lookups(mneu_mg_m12g_m3g_X2_lookups)
#
format='{:<30}: {:30}'
number_format='{:<30}: {:<5.'+str(args.ndigits)+'f}'
float_format='{:<30}: {:<5.3e}'
if args.database_info:
print('='*50)
print(format.format('Data base info',''))
print('='*50)
print(format.format('Rowid',str(args.rowid)))
print(format.format('Database',db))
print(format.format('Collection rowid',str(collection_rowid)))
if args.parameters:
parameters=user.parameters.get(args.parameters)
print('='*50)
print(format.format('parameters','value'))
print('='*50)
for parameter in parameters:
value=ctw.get_value(parameter,vars)
print(number_format.format(parameter,value))
if args.observables:
observables=user.observables.get(args.observables)
print('='*50)
print(format.format('observables','value'))
print('='*50)
for observable in observables:
value=ctw.get_value(observable,vars)
if not ('ssi' in observable) and not ('bsmm' in observable) \
and not (observable=='g-2'):
print(number_format.format(observable,value))
else:
print(float_format.format(observable,value))
if args.breakdown:
# look for chi2 calculators
constraints=user.constraints_sets.get(args.breakdown)
add_chi2_calculator(args.breakdown,constraints)
print('='*50)
print(format.format('constraint','chi2'))
print('='*50)
nmeas=0
for constraint in constraints:
chi2=ctw.get_value(constraint,vars)
if chi2 > 0:
nmeas+=1
constraint=constraint.replace('chi2-','')
print(number_format.format(constraint,chi2))
print('='*50)
print(number_format.format('total',ctw.get_value(args.breakdown,vars)))
print(number_format.format('nmeas',nmeas))
print('='*50)
if args.mc9_table1_data and args.parameters is not None:
print(format.format('table data',''))
print('='*50)
m0=int(round(ctw.get_value('m0',vars),-1))
m12=int(round(ctw.get_value('m12',vars),-1))
A0=int(round(-ctw.get_value('A0',vars),-1))
tanb=int(round(ctw.get_value('tanb',vars),0))
chi2=round(ctw.get_value(args.breakdown,vars),1)
nparameters=len(user.inputs.get(args.inputs))
ndof=nmeas-nparameters
cl=round(ctw.chi2_ndof_to_cl(chi2,ndof)*100,1)
print('{}/{} & {}\% &{} &{} & {} & {}\\\\'.format(chi2,ndof,cl,m0,m12,A0,tanb))
if args.pvalue and args.parameters is not None:
print(format.format('table data',''))
print('='*50)
chi2=round(ctw.get_value(args.breakdown,vars),1)
nparameters=len(user.inputs.get(args.inputs))
ndof=nmeas-nparameters
cl=round(ctw.chi2_ndof_to_cl(chi2,ndof)*100,1)
print('{}/{}: {}%'.format(chi2,ndof,cl))
# if args.inputs is not None and args.parameters is not None:
if args.inputs is not None :
inputs=user.inputs.get(args.inputs)
values=[str(ctw.get_value(parameter,vars)) for parameter in inputs]
print('='*50)
print(format.format('Input to run point',''))
print('='*50)
print(' '.join(values))
if args.array is not None :
array=user.array.get(args.array)
values=[str(ctw.get_value(element,vars)) for element in array]
print(' '.join(values))
