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))