def generateGraph_for_all(valueList, xName, yName, benchmark_name, graph_title="pareto comparison for", name = "various_inputs", graph_dim = "2d", graph_type ="Q_vs_E", n_graphs="one"): assert(1==0, "this graph generation tool can not be used b/c it uses meani") name_counter = 0 fig = plt.figure(figsize=plt.figaspect(0.5)) #--- sanity check if (graph_dim == "3d"): if (graph_type == "Q_E_product"): print "ERROR: graph_teyp and graph_dim are incompatible" sys.exit() ax = fig.gca(projection='3d') #ax = fig.add_subplot(111, projection='3d') ax.set_xlabel('Quality') ax.set_ylabel('mean') ax.set_zlabel('Energy') else: fig, ax = plt.subplots() if (graph_type == "Q_E_product"): plt.ylabel("Q_E_product") plt.xlabel("mean") else: #plt.xscale('log') plt.xlabel("mean") plt.ylabel("Quality") # plt.ylabel(yName) # plt.xlabel(xName) #here #----comment if not proving th s4 pont symbolsToChooseFrom = ['*', 'x', "o", "+","^", '1', '2', "3"] color =['g', 'y', 'r', 'm'] lOf_run_input_list = input_list.lOf_run_input_list number_of_inputs_used = len(lOf_run_input_list) input_results = map(list, [[]]*number_of_inputs_used) base_dir = "/home/local/bulkhead/behzad/usr/local/apx_tool_chain/inputPics/" counter = 0 energy_list_to_be_drawn = [] quality_list_to_be_drawn = [] std_list_to_be_drawn = [] image_list_to_be_drawn = [] z_vals = [] for val in valueList: input_results = map(list, [[]]*number_of_inputs_used) zipped = zip(*val[:-1]) for el in zipped: input_results[el[2]].append(el) for index,res in enumerate(input_results): """ if (counter > 50 ): break """ print counter if len(res) > 0: image_addr = base_dir+lOf_run_input_list[index][0] + ".ppm" mR, mG, mB, stdR, stdG, stdB = cluster_images.calc_image_mean_std(image_addr) if (int(np.mean([mR,mG,mB]))) in z_vals: continue el = map(lambda x: list(x), zip(*res)) quality_values_shifted = map(lambda x: x+1, el[0]) #--here #---un comment the next line whenever you want to provide the resuls t professor, #--- sort based on the quality Q = quality_values_shifted E = el[1] # Q_index_sorted = sorted(enumerate(Q), key=lambda x: x[1]) # index_of_Q_sorted = map(lambda y: y[0], Q_index_sorted) E_index_sorted = sorted(enumerate(E), key=lambda x: x[1]) index_of_E_sorted = map(lambda y: y[0], E_index_sorted) # # Q_sorted = [Q[i] for i in index_of_Q_sorted] # E_sorted = [E[i] for i in index_of_Q_sorted] Q_sorted = [Q[i] for i in index_of_E_sorted] E_sorted = [E[i] for i in index_of_E_sorted] quality_list_to_be_drawn.append(Q_sorted) energy_list_to_be_drawn.append(E_sorted) # std_list_to_be_drawn.append([int(np.mean([stdR,stdG,stdB]))]*len(E_sorted)) # z_vals.append( int(np.mean([stdR,stdG,stdB]))) std_list_to_be_drawn.append([int(np.mean([mR,mG,mB]))]*len(E_sorted)) image_list_to_be_drawn.append([lOf_run_input_list[index][0]]*len(E_sorted)) z_vals.append( int(np.mean([mR,mG,mB]))) counter +=1 reminder(True,"the following lines which creates a new image every len(symbolsToChooseFrom) should be commented if we use any flag but various_inputs") #--sorting the data. This is necessary for wire frame zvals_index_sorted = sorted(enumerate(z_vals), key=lambda x: x[1]) index_of_zvals_sorted = map(lambda y: y[0], zvals_index_sorted) quality_list_sorted_based_on_z = [quality_list_to_be_drawn[i] for i in index_of_zvals_sorted] std_list_sorted_based_on_z = [std_list_to_be_drawn[i] for i in index_of_zvals_sorted] energy_list_sorted_based_on_z = [energy_list_to_be_drawn[i] for i in index_of_zvals_sorted] image_list_sorted_based_on_z = [image_list_to_be_drawn[i] for i in index_of_zvals_sorted] #--- generate a spectrum of colors #colors = ['b', 'g'] n_energy_levels = 4 #colors = gen_color_spec.gen_color(len(quality_list_sorted_based_on_z[0]), 'seismic') colors = gen_color_spec.gen_color(n_energy_levels, 'seismic') print "here is the list of (images in the z_order, quality in z order, energy in z order)" print zip([i[0] for i in image_list_sorted_based_on_z], [i[0] for i in quality_list_sorted_based_on_z], [i[0] for i in std_list_sorted_based_on_z]) print zip([i[0] for i in image_list_sorted_based_on_z], [i[1] for i in quality_list_sorted_based_on_z], [i[0] for i in std_list_sorted_based_on_z]) for x in range(len(energy_list_sorted_based_on_z[0][:n_energy_levels])): #for x in range(len(quality_list_sorted_based_on_z)): #my_label = 'mean:' + str(int(std_list_sorted_based_on_z[x][0])) my_label = 'En:' + str(float(energy_list_sorted_based_on_z[0][x])) if (graph_dim == "3d"): """ the following is for plotting a wire_frame or surface plot surf = ax.plot_surface(np.asarray(energy_list_sorted_based_on_z), np.asarray(quality_list_sorted_based_on_z), np.asarray(std_list_sorted_based_on_z), rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False) fig.colorbar(surf, shrink=0.5, aspect=5) #ax.plot_wireframe(np.asarray(quality_list_sorted_based_on_z), np.asarray(std_list_sorted_based_on_z), np.asarray(energy_list_sorted_based_on_z)) """ ax.scatter(quality_list_sorted_based_on_z[x], std_list_sorted_based_on_z[x] , energy_list_sorted_based_on_z[x], c=colors[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], depthshade=False) else: #my_label += lOf_run_input_list[index][0] #--- note: get rid of linestyle='None' if you want a line through the graph #line_style = 'None' line_style = '-' if (graph_type == "Q_E_product") : Q_E_list = [a*b for a,b in zip(quality_list_sorted_based_on_z[x],energy_list_sorted_based_on_z[x])] ax.plot(std_list_sorted_based_on_z[x], Q_E_list, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) else: #ax.plot(quality_list_sorted_based_on_z[x], energy_list_sorted_based_on_z[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) quality_as_w_diff_mean = map(lambda y: y[x], quality_list_sorted_based_on_z) #--- if no quality value under 150, it is possibly the acc\ # setUP. The accurate set up make seeing other setUPs difficult """ found_one = False for el in quality_as_w_diff_mean: if el < 150: found_one = True break if not(found_one): continue """ l_mean = map(lambda y: y[x], std_list_sorted_based_on_z) ax.plot(l_mean, quality_as_w_diff_mean, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label) #, linestyle=line_style) if (n_graphs == "multiple"): finish_up_making_graph(ax, name, graph_title, benchmark_name, name_counter) fig = plt.figure(figsize=plt.figaspect(0.5)) #--- sanity check if (graph_dim == "3d"): ax = fig.gca(projection='3d') #ax = fig.add_subplot(111, projection='3d') ax.set_xlabel('1/Q') ax.set_ylabel('mean') ax.set_zlabel('Energy') else: fig, ax = plt.subplots() if (graph_type == "Q_E_product"): plt.ylabel("Q_E_product") plt.xlabel("mean") else: #plt.xscale('log') plt.xlabel("mean") plt.ylabel("Quality") # plt.ylabel(yName) # plt.xlabel(xName) name_counter += 1 if (n_graphs == "one"): finish_up_making_graph(ax, name, graph_title, benchmark_name, 0)
def main(): os.system("rm *.png") #--- parameters to set clk_period = .7 #clk period that we ran the DC with num_of_bins = 10 #number of bins for the histogram lower_bound = 28 #lower bound for the output bit you want to make histogram for upper_bound = 32 #upper bound for the output bit you want to make histogram for histogram_type = "2d" #2d #3d histogram will be generated regardless output_bit_to_make_histogram_for = 31 #only for 2d histogram print "clk_period:" + str(clk_period) print "number_of_bins for histogram:" + str(num_of_bins) #--- parse the results and collect slacks data = sourceFileParse("int_add_acc_ff_0_timing1.rpt", clk_period) #sorting for printing purposes my_list = data.keys() my_list.sort(key=lambda x: x[0]) my_list.sort(key=lambda x: x[1]) for key in my_list: print str("pin_tuple:") + str(key) + " ---- slack_values" + str( data[key]) #--- preparing to draw a histogram output_slack_dic = {} for i in range(0, 32): output_slack_dic[i] = [] for key in data.keys(): output_slack_dic[key[1]].append(data[key]) #flattening for key in output_slack_dic.keys(): output_slack_dic[key] = list( itertools.chain.from_iterable(output_slack_dic[key])) #--- draw a 2d histogram if (histogram_type == "2d"): plt.hist(output_slack_dic[output_bit_to_make_histogram_for], 30, range=[0, clk_period]) print output_slack_dic[output_bit_to_make_histogram_for] plt.title("slack Histogram for " + str(output_bit_to_make_histogram_for) + "thbit") plt.xlabel("Value") plt.ylabel("Frequency") pylab.savefig( str(output_bit_to_make_histogram_for) + "th_bit_slack_histogram.png" ) #saving the figure generated by generateGraph #plt.show() #--- draw a 3d histogram fig = plt.figure() ax1 = fig.add_subplot(111, projection='3d') x = [] #list of output bits (stamped to the number of slack value) y = [] #list of slack value for key in output_slack_dic.keys(): x += len(output_slack_dic[key]) * [key] y += output_slack_dic[key] xedges = [] for i in range(0, 33): xedges.append(i) yedges = [] for el in range(num_of_bins): yedges.append((el + 1) * float(clk_period) / float(num_of_bins)) H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) new_yedges = [] for i in range(0, len(xedges[:-1])): for el in yedges[:-1]: new_yedges.append(float(el)) new_xedges = [] for j in range(0, len(xedges[:-1])): for i in range(0, len(yedges[:-1])): new_xedges.append(j) dx = np.ones(len(new_xedges)) dy = np.ones(len(new_xedges)) * .1 colors = gen_color_spec.gen_color(33, 'prism') for x in range(lower_bound, upper_bound): ax1.bar3d([x] * len(yedges[:-1]), yedges[:-1], np.zeros(len(yedges[:-1])), dx, dy, H[x], alpha=.5, color=colors[x]) print "x and y for hisogram:" print "y:" + str(np.array(yedges)) print "x " + str(xedges) print "histogram:" print H """ H_list = (H.tolist()) H_list_flattened = list(itertools.chain.from_iterable(H_list)) dz = H_list_flattened zpos =[0]*len(H_list_flattened) ax1.bar3d(new_xedges, new_yedges, zpos, dx, dy, dz, alpha =.1, color='#00ceaa') """ pylab.savefig("3d_slack_histogram.png" ) #saving the figure generated by generateGraph
def generateGraph_for_all_simplified(valueList,xlabel, ylabel, benchmark_name, ax, fig, graph_title="pareto comparison for", name = "various_inputs", post_pone_saving_graph = False, use_prev_ax_fig = False, n_graphs="one", valueList_promised=[]): name_counter = 0 #fig = plt.figure(figsize=plt.figaspect(0.5)) #--- sanity check if not(use_prev_ax_fig): fig, ax = plt.subplots() plt.autoscale(enable=True, axis='both', tight=True) """ if (graph_type == "Q_E_product"): plt.ylabel("Q_E_product") plt.xlabel("mean") else: #plt.xscale('log') plt.xlabel("mean") plt.ylabel("Energy") # plt.ylabel(yName) # plt.xlabel(xName) """ #here #----comment if not proving th s4 pont symbolsToChooseFrom = ['*', 'x', "o", "+","^", '1', '2', "3"] color =['g', 'y', 'r', 'm'] quality_list_sorted_based_on_z, std_list_sorted_based_on_z, energy_list_sorted_based_on_z = sort_values(valueList) quality_list_promised_sorted_based_on_z, std_list_promised_sorted_based_on_z, energy_list_promised_sorted_based_on_z = sort_values(valueList_promised) """ lOf_run_input_list = input_list.lOf_run_input_list number_of_inputs_used = len(lOf_run_input_list) input_results = map(list, [[]]*number_of_inputs_used) base_dir = "/home/local/bulkhead/behzad/usr/local/apx_tool_chain/inputPics/" counter = 0 energy_list_to_be_drawn = [] setup_list_to_be_drawn = [] quality_list_to_be_drawn = [] std_list_to_be_drawn = [] image_list_to_be_drawn = [] z_vals = [] for val in valueList: input_results = map(list, [[]]*number_of_inputs_used) zipped = zip(*val[:-1]) for el in zipped: input_results[el[2]].append(el) for index,res in enumerate(input_results): print counter if len(res) > 0: image_addr = base_dir+lOf_run_input_list[index][0] + ".ppm" mR, mG, mB, stdR, stdG, stdB = cluster_images.calc_image_mean_std(image_addr) if (int(np.mean([mR,mG,mB]))) in z_vals: continue el = map(lambda x: list(x), zip(*res)) quality_values_shifted = map(lambda x: x+1, el[0]) print "mean of image : " + (lOf_run_input_list[index][0]) + " is: " + str(np.mean([mR,mG,mB])) #--- sort based on the quality Q = quality_values_shifted E = el[1] SetUps = el[2] E_index_sorted = sorted(enumerate(E), key=lambda x: x[1]) index_of_E_sorted = map(lambda y: y[0], E_index_sorted) Q_sorted = [Q[i] for i in index_of_E_sorted] E_sorted = [E[i] for i in index_of_E_sorted] SetUp_sorted = [SetUps[i] for i in index_of_E_sorted] quality_list_to_be_drawn.append(Q_sorted) energy_list_to_be_drawn.append(E_sorted) setup_list_to_be_drawn.append(SetUp_sorted) std_list_to_be_drawn.append([int(np.mean([mR,mG,mB]))]*len(E_sorted)) image_list_to_be_drawn.append([lOf_run_input_list[index][0]]*len(E_sorted)) z_vals.append( int(np.mean([mR,mG,mB]))) counter +=1 reminder(True,"the following lines which creates a new image every len(symbolsToChooseFrom) should be commented if we use any flag but various_inputs") #--sorting the data. This is necessary for wire frame zvals_index_sorted = sorted(enumerate(z_vals), key=lambda x: x[1]) index_of_zvals_sorted = map(lambda y: y[0], zvals_index_sorted) quality_list_sorted_based_on_z = [quality_list_to_be_drawn[i] for i in index_of_zvals_sorted] std_list_sorted_based_on_z = [std_list_to_be_drawn[i] for i in index_of_zvals_sorted] energy_list_sorted_based_on_z = [energy_list_to_be_drawn[i] for i in index_of_zvals_sorted] image_list_sorted_based_on_z = [image_list_to_be_drawn[i] for i in index_of_zvals_sorted] SetUp_list_sorted_based_on_z = [setup_list_to_be_drawn[i] for i in index_of_zvals_sorted] print quality_list_sorted_based_on_z print std_list_sorted_based_on_z print energy_list_sorted_based_on_z """ if (post_pone_saving_graph): line_style = ':' else: line_style = '-' #--- generate a spectrum of colors #colors = ['b', 'g'] plt.xscale('log') if (name == "same_Q_vs_input"): plt.xlabel("mean") plt.ylabel("Energy") Qs, Es, stds, QSs = adjust.adjust_vals_2(quality_list_sorted_based_on_z, energy_list_sorted_based_on_z, std_list_sorted_based_on_z) second_axis = Es; third_axis = QSs; third_axis_name = "quality" #---limiting #third_axis= QSs[:10] n_lines = len(third_axis) colors = gen_color_spec.gen_color(max(n_lines,2), 'seismic') #---limiting #--- printing the the Qstates (Q attempted) and the Q found for input_index in range(len(Qs)): print "true Qs for input with mean:" + str(stds[input_index]) + "is:" for x in range(len(third_axis)): print "Q state:" + str(third_axis[x]) + " found Q:" + str(Qs[input_index][x]) + "En is: " + str(Es[input_index][x]) for x in range(len(third_axis)): my_label = third_axis_name +": " + str(float(third_axis[x])) second_axis_as_w_diff_mean = map(lambda y: y[x], second_axis) l_mean = map(lambda y: y[x], stds) ax.plot(l_mean, second_axis_as_w_diff_mean, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) #finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, 0) elif (name == "same_E_vs_input"): plt.xlabel("mean") plt.ylabel("quality") sys.stdout.flush() third_axis= energy_list_sorted_based_on_z[0]; third_axis_name = "energy" second_axis = quality_list_sorted_based_on_z; n_lines = len(third_axis) colors = gen_color_spec.gen_color(n_lines, 'seismic') for x in range(len(third_axis)): #--- limiting # if x > 10: # break; my_label = third_axis_name +": " + str(float(third_axis[x])) second_axis_as_w_diff_mean = map(lambda y: y[x], second_axis) l_mean = map(lambda y: y[x], std_list_sorted_based_on_z) print "asdf" + str(second_axis_as_w_diff_mean ) ax.plot(l_mean, second_axis_as_w_diff_mean, marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) #finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, 0) elif(name == "E_vs_Q_adjusted"): plt.xlabel("Quality") plt.ylabel("Energy") Qs, Es, stds, QSs = adjust.adjust_vals_2(quality_list_sorted_based_on_z, energy_list_sorted_based_on_z, std_list_sorted_based_on_z) second_axis = Es; third_axis = std_list_sorted_based_on_z; third_axis_name = "input" n_lines = len(std_list_sorted_based_on_z) colors = gen_color_spec.gen_color(n_lines, 'seismic') for x in range(len(third_axis)): my_label = third_axis_name +": " + str(float(third_axis[x][0])) #if (third_axis[x][0] == 97): ax.plot(QSs, Es[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) elif (name == "E_vs_Q"): #---line_style = '' uncomment for all_points plt.xlabel("Quality") plt.ylabel("Energy") third_axis = std_list_sorted_based_on_z; third_axis_name = "input" n_lines = len(std_list_sorted_based_on_z) colors = gen_color_spec.gen_color(n_lines, 'seismic') if (graph_title == "E_vs_Q_all_points"): line_style = "None" #for no lines for x in range(len(third_axis)): my_label = third_axis_name +": " + str(float(third_axis[x][0])) ax.plot(quality_list_sorted_based_on_z[x], energy_list_sorted_based_on_z[x], marker = symbolsToChooseFrom[x%len(symbolsToChooseFrom)], c= colors[x], label=my_label, linestyle=line_style) if (graph_title == "E_vs_Q_all_points"): #.n the counter would be an incremented version of the input #value n. finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, x+1) fig, ax = plt.subplots() plt.xscale('log') plt.xlabel("Quality") plt.ylabel("Energy") elif (name == "Qstd_vs_E_imposed"): plt.ylabel("Quality_std") plt.xlabel("Energy") n_lines = 1 colors = gen_color_spec.gen_color(n_lines, 'seismic') my_label = "nolabel" Q_diff = [] for E_index in range(len(energy_list_sorted_based_on_z[0])): all_Qs_as_w_index = map(lambda x: x[E_index], quality_list_sorted_based_on_z) Q_diff.append(numpy.std(all_Qs_as_w_index)) ax.plot(energy_list_sorted_based_on_z[0], Q_diff, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[0], label=my_label, linestyle=line_style) elif (name == "Qmean_normalized_to_Q_promissed"): plt.ylabel("Quality_mean_normalized_to_Q_promised") plt.xlabel("Energy") n_lines = 1 colors = gen_color_spec.gen_color(max(n_lines,2), 'seismic') Q_diff_1 = [] Q_diff_2 = [] for E_index in range(len(energy_list_sorted_based_on_z[0])): all_Qs_as_w_index = map(lambda x: x[E_index], quality_list_sorted_based_on_z) print "all_Qs" + str(all_Qs_as_w_index) Q_diff_1.append(numpy.mean(all_Qs_as_w_index)) print "quality_promiseed" + str(quality_list_promised_sorted_based_on_z[0]) imposed_vs_got_diff = map(operator.sub, [quality_list_promised_sorted_based_on_z[0][E_index]]*len(all_Qs_as_w_index), all_Qs_as_w_index) Q_diff_2.append(numpy.mean(imposed_vs_got_diff)) print "Q_diff_2)" + str(Q_diff_2) #ax.plot(energy_list_sorted_based_on_z[0], Q_diff_1, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[0], label="Q_mean", linestyle=line_style) ax.plot(energy_list_sorted_based_on_z[0], Q_diff_2, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[1], label="Q_mean_"+"normalized", linestyle=line_style) elif (name == "Q_satisfaction_success_rate"): plt.ylabel("Q_satisfaction_success_rate") plt.xlabel("Energy") n_lines = 1 colors = gen_color_spec.gen_color(max(n_lines,2), 'seismic') my_label = "nolabel" Q_diff_2 = [] for E_index in range(len(energy_list_sorted_based_on_z[0])): all_Qs_as_w_index = map(lambda x: x[E_index], quality_list_sorted_based_on_z) imposed_vs_got_diff = map(operator.sub, all_Qs_as_w_index, [quality_list_promised_sorted_based_on_z[0][E_index]]*len(all_Qs_as_w_index)) print "sub_is2" + str(imposed_vs_got_diff) success_rate = float(len(filter(lambda x: x >= 000, imposed_vs_got_diff)))/float(len(imposed_vs_got_diff)) Q_diff_2.append(success_rate) ax.get_yaxis().get_major_formatter().set_useOffset(False) ax.plot(energy_list_sorted_based_on_z[0], Q_diff_2, marker = symbolsToChooseFrom[0%len(symbolsToChooseFrom)], c= colors[1], label="Q_satisfaction_success_rate", linestyle=line_style) else: print "this name : " + name + " is not defined" sys.exit() if not(post_pone_saving_graph): finish_up_making_graph(ax, graph_title, graph_title, benchmark_name, 0) return ax, fig
def main(): os.system("rm *.png") #--- parameters to set #result_type = "slack" result_type = "delay" clk_period = .55 #clk period that we ran the DC with num_of_bins = 10 #number of bins for the histogram lower_bound = 28 #lower bound for the bit you want to make histogram for upper_bound = 32 #upper bound for the bit you want to make histogram for histogram_type = "2d" #2d #3d histogram will be generated regardless histogram_var = "input" #if input, slack of ass/w input pins are shown #histogram_type = "ouput" bit_to_make_histogram_for = 0 #only for 2d histogram print "clk_period:" + str(clk_period) print "number_of_bins for histogram:" + str(num_of_bins) data_2 = {} #--- parse the results and collect slacks #data = sourceFileParse("int_add_acc_ff_0_timing1.rpt", clk_period) #file_to_parse = "unconfig_int_add_32Bit_timing.rpt" file_to_parse = "config_int_add_inMux_truncation_16_timing.rpt" print colored("ensure clk_period validity" + str(clk_period), 'blue') print colored("ensure parsed timing file " + file_to_parse, "blue") data = sourceFileParse(file_to_parse, clk_period) if (result_type == "delay"): for el in data.keys(): temporary_list = data[el] temporary_list_2 = [] for value in temporary_list: temporary_list_2.append(clk_period - value) data[el] = temporary_list_2 """ for el in data.keys(): print data[el] print data_2[el] sys.exit() """ #sorting for printing purposes my_list = data.keys() my_list.sort(key=lambda x: x[0]) my_list.sort(key=lambda x: x[1]) for key in my_list: print str("pin_tuple:") + str( key) + " ---- " + result_type + "_values" + str(data[key]) #--- preparing to draw a histogram result_dic = {} for i in range(0, 32): result_dic[i] = [] for key in data.keys(): if histogram_var == "input": result_dic[key[0]].append(data[key]) elif histogram_var == "output": result_dic[key[1]].append(data[key]) else: print "This histogram_var not defined" sys.exit() ##--- flattening for key in result_dic.keys(): result_dic[key] = list(itertools.chain.from_iterable(result_dic[key])) #--- draw a 2d histogram of #--- the folowing is if we want to have a cumulitive histogram all_results = [] for i in range(0, 32): #which bits to show histogram for all_results += result_dic[i] print all_results if (histogram_type == "2d"): # plt.hist(result_dic[bit_to_make_histogram_for], 30, # range=[0, clk_period]) plt.hist(all_results, 30, range=[0, clk_period]) # print result_dic[bit_to_make_histogram_for] plt.title(result_type + " Histogram Associated With the " + str(bit_to_make_histogram_for) + "th bit (and lower) of the " + histogram_var) plt.xlabel(result_type + "Value") plt.ylabel("Frequency") pylab.savefig( result_type + "_histogram_" + histogram_var + str(bit_to_make_histogram_for) + "th_bit.png") #saving the figure generated by generateGraph #plt.show() #--- draw a 3d histogram fig = plt.figure() ax1 = fig.add_subplot(111, projection='3d') x = [] #list of bits (stamped to the number of result value) y = [] #list of result value for key in result_dic.keys(): x += len(result_dic[key]) * [key] y += result_dic[key] xedges = [] for i in range(0, 33): xedges.append(i) yedges = [] for el in range(num_of_bins): yedges.append((el + 1) * float(clk_period) / float(num_of_bins)) H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) new_yedges = [] for i in range(0, len(xedges[:-1])): for el in yedges[:-1]: new_yedges.append(float(el)) new_xedges = [] for j in range(0, len(xedges[:-1])): for i in range(0, len(yedges[:-1])): new_xedges.append(j) dx = np.ones(len(new_xedges)) dy = np.ones(len(new_xedges)) * .1 colors = gen_color_spec.gen_color(33, 'prism') for x in range(lower_bound, upper_bound): ax1.bar3d([x] * len(yedges[:-1]), yedges[:-1], np.zeros(len(yedges[:-1])), dx, dy, H[x], alpha=.5, color=colors[x]) print "x and y for hisogram:" print "y:" + str(np.array(yedges)) print "x " + str(xedges) print "histogram:" print H """ H_list = (H.tolist()) H_list_flattened = list(itertools.chain.from_iterable(H_list)) dz = H_list_flattened zpos =[0]*len(H_list_flattened) ax1.bar3d(new_xedges, new_yedges, zpos, dx, dy, dz, alpha =.1, color='#00ceaa') """ pylab.savefig( "3d_" + result_type + "_histogram.png") #saving the figure generated by generateGraph