def angle_heapmaps(description, zextractor): configuration_names = Configuration.names() configurations = [Configuration.create_specific(name, 11, 4.5, "topology") for name in Configuration.names()] #Get rid of configurations that aren't grids configurations = filter(lambda c: isinstance(c.topology, Grid), configurations) # Get rid of configurations that do not have 2 sources configurations = filter(lambda c: len(c.source_ids) == 2, configurations) grapher = configuration_heatmap.Grapher("results/Configurations", description, zextractor) grapher.nokey = True grapher.xaxis_label = "X Coordinate" grapher.yaxis_label = "Y Coordinate" grapher.cb_label = "Source Angle" grapher.dgrid3d_dimensions = "11,11" grapher.cbrange = (0, 180) grapher.create(configurations) summary_grapher = summary.GraphSummary( os.path.join("results/Configurations", description), '{}-{}'.format("results/Configurations", description) ) summary_grapher.width_factor = None summary_grapher.height = "7cm" summary_grapher.run()
def _run_average_graph(self, args): from data.graph import combine_versus graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'right top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), } phantom_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys()), source_period_normalisation="NumSources" ) custom_yaxis_range_max = { 'captured': 80, 'sent': 30000 } combine = ["short walk length", "long walk length"] parameters = [ ('source period', ' seconds'), ] for (parameter_name, parameter_unit) in parameters: for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-{}-i-{}'.format( yaxis.replace(" ", "_"), parameter_name.replace(" ", "-"), "=".join(combine).replace(" ", "-") ) g = combine_versus.Grapher( self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary=parameter_name, combine=combine, combine_function=np.mean, yextractor=scalar_extractor ) g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.vary_label = parameter_name.title() g.vary_prefix = parameter_unit g.key_position = key_position if yaxis in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[yaxis] g.create(phantom_results) summary.GraphSummary( self.algorithm_module.graphs_path, self.algorithm_module.name + '-' + name ).run()
def _run_graph_bar(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'right top'), 'ssd': ('Sink-Source Distance (hops)', 'right top'), 'captured': ('Capture Ratio (%)', 'right top'), 'sent': ('Total Messages Sent', 'right top'), 'received ratio': ('Receive Ratio (%)', 'right top'), 'attacker distance': ('Meters', 'right top'), 'norm(sent,time taken)': ('Messages Sent per Second', 'left top'), 'norm(norm(sent,time taken),network size)': ('Messages Sent per Node per Second', 'left top'), } vary = "genetic header" parameters = self.algorithm_module.local_parameter_names if vary not in parameters: parameters += (vary, ) slp_tdma_das_ga_results = results.Results( self.algorithm_module.result_file_path, parameters=parameters + ('fitness function', ), results=tuple(graph_parameters.keys())) def xextractor(xname): return "/".join( x.replace("slot-with-path-", "").replace( "low-asymmetry", "low") for x in xname) def vextractor(vvalue): return int( vvalue.replace(".h", "").replace("dist", "").replace("slot", "")) for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-{}'.format(yaxis.replace(" ", "_"), "gh") #vary.replace(" ", "-")) g = bar.Grapher(self.algorithm_module.graphs_path, name, xaxis=('communication model', 'fitness function'), yaxis=yaxis, vary=vary, yextractor=scalar_extractor) g.nokey = True g.yaxis_label = yaxis_label g.key_position = key_position g.xextractor = xextractor g.vextractor = vextractor g.xtics_around_cluster = True g.create(slp_tdma_das_ga_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join(algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name))).run()
def graph_min_max_versus(result_name, xaxis): name = 'min-max-{}-versus-{}-{}'.format(adaptive.name, result_name, xaxis) g = min_max_versus.Grapher(self.algorithm_module.graphs_path, name, xaxis=xaxis, yaxis=result_name, vary='approach', yextractor=scalar_extractor) g.xaxis_label = xaxis.title() g.yaxis_label = graph_parameters[result_name][0] g.key_position = graph_parameters[result_name][1] g.yaxis_font = g.xaxis_font = "',15'" #g.nokey = True #g.key_font = "',20'" #g.key_spacing = "2" #g.key_width = "+6" g.point_size = '2' g.line_width = 2 g.min_label = ['Dynamic - Lowest', 'Static - Lowest'] g.max_label = ['Dynamic - Highest', 'Static - Highest'] g.comparison_label = 'DynamicSpr' g.vary_label = '' if result_name in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[result_name] def vvalue_converter(name): return { "PB_FIXED1_APPROACH": "Fixed1", "PB_FIXED2_APPROACH": "Fixed2", "PB_RND_APPROACH": "Rnd", }[name] g.vvalue_label_converter = vvalue_converter g.generate_legend_graph = True if result_name in protectionless_results.result_names: g.create([adaptive_results, template_results], adaptive_spr_results, baseline_results=protectionless_results) else: g.create([adaptive_results, template_results], adaptive_spr_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_"))).run()
def _run_graph(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'left top'), 'fake': ('Fake Messages Sent', 'left top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'tfs': ('Number of TFS Created', 'left top'), 'pfs': ('Number of PFS Created', 'left top'), 'attacker distance': ('Meters', 'left top'), 'good move ratio': ('Good Move Ratio (%)', 'right top'), 'norm(norm(sent,time taken),num_nodes)': ('Messages Sent per node per second', 'right top'), } adaptive_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys()), source_period_normalisation="NumSources") varying = [("source period", " seconds"), ("communication model", "~")] error_bars = set( ) # {'received ratio', 'good move ratio', 'norm(norm(sent,time taken),num_nodes)'} for (vary, vary_prefix) in varying: for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-{}'.format(yaxis.replace(" ", "_"), vary.replace(" ", "-")) g = versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary=vary, yextractor=scalar_extractor) g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.vary_label = vary.title() g.vary_prefix = vary_prefix g.error_bars = yaxis in error_bars #g.nokey = True g.key_position = key_position g.create(adaptive_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), '{}-{}'.format(self.algorithm_module.name, name)).run()
def graph_min_max_versus(result_name): name = 'min-max-{}-versus-{}'.format(template.name, result_name) g = min_max_versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=result_name, vary='approach', yextractor=scalar_extractor) g.xaxis_label = 'Network Size' g.yaxis_label = graph_parameters[result_name][0] g.key_position = graph_parameters[result_name][1] g.yaxis_font = g.xaxis_font = "',15'" g.nokey = True #g.key_font = "',20'" #g.key_spacing = "2" #g.key_width = "-5.5" g.point_size = '2' g.line_width = 2 g.min_label = 'Static - Lowest' g.max_label = 'Static - Highest' g.comparison_label = 'Dynamic' g.vary_label = '' if result_name in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[result_name] def vvalue_converter(name): return { 'PB_SINK_APPROACH': 'Pull Sink', 'PB_ATTACKER_EST_APPROACH': 'Pull Attacker' }[name] g.vvalue_label_converter = vvalue_converter g.generate_legend_graph = True g.create(template_results, adaptive_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_"))).run()
def graph_min_max_versus(result_name): name = 'min-max-{}-versus-{}'.format(adaptive.name, result_name) yextractor = lambda x: scalar_extractor(x.get((0, 0), None)) if result_name == 'attacker distance' else scalar_extractor(x) g = min_max_versus.Grapher( self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=result_name, vary='approach', yextractor=yextractor) g.xaxis_label = 'Network Size' g.yaxis_label = graph_parameters[result_name][0] g.key_position = graph_parameters[result_name][1] g.yaxis_font = g.xaxis_font = "',15'" g.nokey = True #g.key_font = "',20'" #g.key_spacing = "2" #g.key_width = "+6" g.point_size = '2' g.line_width = 4 g.min_label = 'Dynamic - Lowest' g.max_label = 'Dynamic - Highest' g.comparison_label = 'DynamicSpr' g.vary_label = '' if result_name in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[result_name] def vvalue_converter(name): return { "PB_FIXED1_APPROACH": "Fixed1", "PB_FIXED2_APPROACH": "Fixed2", "PB_RND_APPROACH": "Rnd", }[name] g.vvalue_label_converter = vvalue_converter g.generate_legend_graph = True if result_name in protectionless_results.result_names: g.create(adaptive_spr_results, our_results, baseline_results=protectionless_results) else: g.create(adaptive_spr_results, our_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_") ).run()
def create_comp_bar(show, pc=False): name = 'template-comp-{}-{}'.format(show, "pcdiff" if pc else "diff") bar.DiffGrapher( self.algorithm_module.graphs_path, result_table, name, shows=[show], extractor=lambda x: x[1] if pc else x[0] #(diff, pcdiff) ).create() summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_"))).run()
def _run_graph(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'left top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'attacker distance': ('Meters', 'left top'), 'crash': ('Number of crash messages sent', 'left top'), } slp_tdma_das_crash_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys()), network_size_normalisation="UseNumNodes") for (vary, vary_prefix) in [("source period", " seconds")]: for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-{}'.format(yaxis.replace(" ", "_"), vary.replace(" ", "-")) g = versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary=vary, yextractor=scalar_extractor) g.xaxis_label = 'Number of Nodes' g.yaxis_label = yaxis_label g.vary_label = vary.title() g.vary_prefix = vary_prefix g.key_position = key_position g.create(slp_tdma_das_crash_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name))).run()
def _run_graph(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'left top'), 'fake': ('Fake Messages Sent', 'left top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'tfs': ('Number of TFS Created', 'left top'), 'pfs': ('Number of PFS Created', 'left top'), 'tailfs': ('Number of TailFS Created', 'left top'), 'attacker distance': ('Attacker Distance From Source (Meters)', 'left top'), } adaptive_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys())) for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-source-period'.format(yaxis.replace(" ", "_")) g = versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary='source period', yextractor=scalar_extractor) g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.vary_label = 'Source Period' g.vary_prefix = ' seconds' g.key_position = key_position g.create(adaptive_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join(algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name))).run()
def _run_graph(self, args): graph_parameters = { 'safety period': ('Safety Period (seconds)', 'left top'), 'time taken': ('Time Taken (seconds)', 'left top'), #'ssd': ('Sink-Source Distance (hops)', 'left top'), #'captured': ('Capture Ratio (%)', 'left top'), #'sent': ('Total Messages Sent', 'left top'), #'received ratio': ('Receive Ratio (%)', 'left bottom'), } protectionless_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys()), source_period_normalisation="NumSources") for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-configuration'.format(yaxis.replace(" ", "_")) g = versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary='configuration', yextractor=scalar_extractor) g.generate_legend_graph = True g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.vary_label = '' g.vary_prefix = '' g.nokey = True g.key_position = key_position g.create(protectionless_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), '{}-{}'.format(self.algorithm_module.name, name)).run()
def _run_graph(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'right top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'paths reached end': ('Paths Reached End (%)', 'right top'), } phantom_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys())) parameters = [('source period', ' seconds'), ('walk length', ' hops')] for (parameter_name, parameter_unit) in parameters: for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-{}'.format(yaxis.replace(" ", "_"), parameter_name.replace(" ", "-")) g = versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary=parameter_name, yextractor=scalar_extractor) g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.vary_label = parameter_name.title() g.vary_prefix = parameter_unit g.key_position = key_position g.create(phantom_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), self.algorithm_module.name + '-' + name).run()
def _run_scatter_graph(self, args): from data.graph import scatter graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'right top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), } phantom_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys()), source_period_normalisation="NumSources" ) combine = ["short walk length", "long walk length"] for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-comb-{}'.format(yaxis.replace(" ", "_"), "=".join(combine).replace(" ", "-")) g = scatter.Grapher( self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, combine=combine, yextractor=scalar_extractor ) g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.key_position = key_position g.create(phantom_results) summary.GraphSummary( self.algorithm_module.graphs_path, self.algorithm_module.name + '-' + name ).run()
def create_comp_bar_pcdiff(pc=True, modified=lambda x: x, name_addition=None, shows=results_to_compare): name = 'template-comp-{}'.format("pcdiff" if pc else "diff") if name_addition is not None: name += '-{}'.format(name_addition) # Normalise wrt to the number of nodes in the network def normalisor(key_names, key_values, params, yvalue): size = key_values[key_names.index('size')] result = yvalue / (size * size) return modified(result) g = bar.DiffGrapher( self.algorithm_module.graphs_path, result_table, name, shows=shows, extractor=lambda x: x[1] if pc else x[0], #(diff, pcdiff) normalisor=normalisor) g.yaxis_label = 'Percentage Difference per Node' if pc else 'Average Difference per Node' if name_addition is not None: g.yaxis_label += ' ({})'.format(name_addition) g.xaxis_label = 'Parameters (P_{TFS}, D_{TFS}, Pr(TFS), Pr(PFS))' g.create() summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_"))).run()
def graph_min_max_versus(result_name, xaxis): name = 'min-max-ilp-versus-{}-{}'.format(result_name, xaxis) if result_name == "attacker distance": # Just get the distance of attacker 0 from node 0 (the source in SourceCorner) def yextractor(yvalue): print(yvalue) return scalar_extractor(yvalue, key=(0, 0)) else: yextractor = scalar_extractor vary = [ 'approach', 'approach', ('buffer size', 'max walk length', 'pr direct to sink', 'msg group size') ] g = min_max_versus.Grapher(args.sim, self.algorithm_module.graphs_path( args.sim), name, xaxis=xaxis, yaxis=result_name, vary=vary, yextractor=yextractor) g.xaxis_label = xaxis.title() g.yaxis_label = graph_parameters[result_name][0] g.key_position = graph_parameters[result_name][1] g.xaxis_font = "',16'" g.yaxis_font = "',16'" g.xlabel_font = "',14'" g.ylabel_font = "',14'" g.line_width = 3 g.point_size = 1 g.nokey = True g.legend_font_size = 16 #g.min_label = ['Static - Lowest'] #g.max_label = ['Static - Highest'] g.comparison_label = ['Dynamic', 'DynamicSpr', 'ILPRouting'] g.vary_label = '' if xaxis == 'network size': g.xvalues_to_tic_label = lambda x: f'"{x}x{x}"' if result_name in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[result_name] def vvalue_converter(name): if isinstance(name, tuple): (buffer_size, max_walk_length, pr_direct_to_sink, msg_group_size) = name return f"Group Size {msg_group_size}" try: return { "PB_FIXED1_APPROACH": "Fixed1", "PB_FIXED2_APPROACH": "Fixed2", "PB_RND_APPROACH": "Rnd", }[name] except KeyError: return name g.vvalue_label_converter = vvalue_converter # Want to pretend SeqNosOOOReactiveAttacker is SeqNosReactiveAttacker def correct_data_key(data_key): data_key = list(data_key) data_key[sim.global_parameter_names.index( 'attacker model')] = "SeqNosReactiveAttacker()" return tuple(data_key) g.correct_data_key = correct_data_key g.generate_legend_graph = True if result_name in protectionless_results.result_names: g.create([], [ adaptive_results, adaptive_spr_notify_results, ilprouting_results ], baseline_results=protectionless_results) else: g.create([], [ adaptive_results, adaptive_spr_notify_results, ilprouting_results ]) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path(args.sim), name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_"))).run()
def graph_min_max_versus(result_name, xaxis): name = 'min-max-{}-versus-{}-{}'.format(adaptive.name, result_name, xaxis) if result_name == "attacker distance": # Just get the distance of attacker 0 from node 0 (the source in SourceCorner) def yextractor(yvalue): print(yvalue) return scalar_extractor(yvalue, key=(0, 0)) else: yextractor = scalar_extractor g = min_max_versus.Grapher(args.sim, self.algorithm_module.graphs_path( args.sim), name, xaxis=xaxis, yaxis=result_name, vary='approach', yextractor=yextractor) g.xaxis_label = xaxis.title() g.yaxis_label = graph_parameters[result_name][0] g.key_position = graph_parameters[result_name][1] g.xaxis_font = "',16'" g.yaxis_font = "',16'" g.xlabel_font = "',14'" g.ylabel_font = "',14'" g.line_width = 3 g.point_size = 1 g.nokey = True g.legend_font_size = 16 g.min_label = ['Static - Lowest'] g.max_label = ['Static - Highest'] g.comparison_label = ['Dynamic', 'DynamicSpr'] g.vary_label = '' if xaxis == 'network size': g.xvalues_to_tic_label = lambda x: f'"{x}x{x}"' if result_name in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[result_name] def vvalue_converter(name): try: return { "PB_FIXED1_APPROACH": "Fixed1", "PB_FIXED2_APPROACH": "Fixed2", "PB_RND_APPROACH": "Rnd", }[name] except KeyError: return name g.vvalue_label_converter = vvalue_converter g.generate_legend_graph = True if result_name in protectionless_results.result_names: g.create([template_results], [adaptive_results, adaptive_spr_notify_results], baseline_results=protectionless_results) else: g.create([template_results], [adaptive_results, adaptive_spr_notify_results]) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path(args.sim), name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name).replace(" ", "_"))).run()
def _run_graph(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'right top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'paths reached end': ('Paths Reached End (%)', 'right top'), 'source dropped': ('Source Dropped Messages (%)', 'right top'), } custom_yaxis_range_max = { 'source dropped': 100, 'paths reached end': 100, } phantom_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys()), network_size_normalisation="UseNumNodes") parameters = [('source period', ' seconds'), ('walk length', ' hops')] for (parameter_name, parameter_unit) in parameters: for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-{}'.format(yaxis.replace(" ", "_"), parameter_name.replace(" ", "-")) g = versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary=parameter_name, yextractor=scalar_extractor) g.xaxis_label = 'Number of Nodes' g.yaxis_label = yaxis_label g.vary_label = parameter_name.title() g.vary_prefix = parameter_unit g.key_position = key_position g.nokey = True g.generate_legend_graph = True g.point_size = 1.3 g.line_width = 4 g.yaxis_font = "',14'" g.xaxis_font = "',12'" if yaxis in custom_yaxis_range_max: g.yaxis_range_max = custom_yaxis_range_max[yaxis] g.create(phantom_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join(algorithm.results_directory_name, self.algorithm_module.name + '-' + name)).run()
configurations = filter(lambda c: isinstance(c.topology, Grid), configurations) def zextractor(configuration, nid): return min(configuration.node_source_distance(nid, src_id) for src_id in configuration.source_ids) grapher = configuration_heatmap.Grapher("results/Configurations", "min-src-distance", zextractor) grapher.nokey = True grapher.xaxis_label = "X Coordinate" grapher.yaxis_label = "Y Coordinate" grapher.cb_label = "Minimum Source Distance (m)" grapher.create(configurations) summary_grapher = summary.GraphSummary( os.path.join("results/Configurations", "min-src-distance"), '{}-{}'.format("results/Configurations", "min-src-distance") ) summary_grapher.width_factor = None summary_grapher.height = "7cm" summary_grapher.run() def angle_heapmaps(description, zextractor): configuration_names = Configuration.names() configurations = [Configuration.create_specific(name, 11, 4.5, "topology") for name in Configuration.names()] #Get rid of configurations that aren't grids
def _run_graph_versus_baseline(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'left top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'attacker distance': ('Meters', 'left top'), 'norm(sent,time taken)': ('Messages Sent per Second', 'left top'), 'norm(norm(sent,time taken),network size)': ('Messages Sent per Second per Node', 'left top'), } protectionless_tdma_das_results = results.Results( protectionless_tdma_das.result_file_path, parameters=protectionless_tdma_das.local_parameter_names, results=list( set(graph_parameters.keys()) & set(protectionless_tdma_das.Analysis.Analyzer.results_header( ).keys()))) slp_tdma_das_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=tuple(graph_parameters.keys())) for (vary, vary_prefix) in [("source period", " seconds")]: for (yaxis, (yaxis_label, key_position)) in graph_parameters.items(): name = '{}-v-baseline-{}'.format(yaxis.replace(" ", "_"), vary.replace(" ", "-")) g = baseline_versus.Grapher(self.algorithm_module.graphs_path, name, xaxis='network size', yaxis=yaxis, vary=vary, yextractor=scalar_extractor) g.xaxis_label = 'Network Size' g.yaxis_label = yaxis_label g.vary_label = vary.title() + " -" #g.vary_prefix = vary_prefix g.key_position = key_position g.force_vvalue_label = True g.result_label = "SLP TDMA DAS" g.baseline_label = "Protectionless TDMA DAS" g.nokey = True g.generate_legend_graph = True g.legend_font_size = '8' g.create(slp_tdma_das_results, baseline_results=protectionless_tdma_das_results) summary.GraphSummary( os.path.join(self.algorithm_module.graphs_path, name), os.path.join( algorithm.results_directory_name, '{}-{}'.format(self.algorithm_module.name, name))).run()