def _run_comparison_table(self, args): results_to_compare = ('normal latency', 'ssd', 'captured', 'fake', 'received ratio', 'tfs', 'pfs') adaptive_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=results_to_compare) template_results = results.Results(template.result_file_path, parameters=('fake period', 'temp fake duration', 'pr(tfs)', 'pr(pfs)'), results=results_to_compare) result_table = comparison.ResultTable(template_results, adaptive_results) self._create_table( "adaptive-template-comparison", result_table, lambda x: x[2] not in {0.2, 0.3, 0.4}) #(fp, dur, ptfs, ppfs) self._create_table( "adaptive-template-comparison-low-prob", result_table, lambda x: x[2] in {0.2, 0.3, 0.4}) #(fp, dur, ptfs, ppfs)
def _run_table(self, args): adaptive_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=( 'sent', 'delivered', 'time taken', 'normal latency', 'ssd', 'captured', 'fake', 'received ratio', 'tfs', 'pfs', 'energy impact per node per second', #'norm(sent,time taken)', 'norm(norm(sent,time taken),network size)', #'norm(norm(norm(sent,time taken),network size),source rate)' )) result_table = fake_result.ResultTable(adaptive_results) self._create_table(self.algorithm_module.name + "-results", result_table, show=args.show)
def transform(self, result_names): all_result_names = tuple(set(result_names) | set(self.comparison_functions.keys())) module_results = [ results.Results( self.sim_name, module.result_file_path(self.sim_name), parameters=module.local_parameter_names, results=all_result_names) for module in self.algorithm_modules ] for (module, module_result) in zip(self.algorithm_modules, module_results): self.safety_factor_indexes[module.name] = module_result.parameter_names.index("safety factor") if self.remove_redundant_parameters: self._remove_redundant_parameters(module_results) # Combine everything combined_results = self._combine_results(module_results) # Find the dominating data dominating_data, self.dominated_data = self._filter_strictly_worse(combined_results, all_result_names) # Split up the data back into the individual chunks split_results = self._convert_dominating_to_individual(dominating_data) # Reassign it for (module_result, module) in zip(module_results, self.algorithm_modules): module_result.data = split_results[module.name] module_result.global_parameter_names = self.global_parameter_names return module_results
def _run_table(self, args): result_file_path = self.get_results_file_path(args.sim, testbed=args.testbed) adaptive_results = results.Results( args.sim, result_file_path, parameters=self.algorithm_module.local_parameter_names, results=( 'repeats', #'sent', 'delivered', 'norm(norm(fake,time taken),network size)', 'time taken', 'normal latency', 'ssd', 'captured', 'fake', 'received ratio', 'attacker distance', #'tfs', 'pfs', #'norm(sent,time taken)', 'norm(norm(sent,time taken),network size)', #'norm(norm(norm(sent,time taken),network size),source rate)' )) result_table = fake_result.ResultTable(adaptive_results) self._create_table(self.algorithm_module.name + "-results", result_table, show=args.show)
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 _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_comparison_table(self, args): results_to_compare = ('normal latency', 'ssd', 'captured', 'fake', 'received ratio', 'tfs', 'pfs') our_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=results_to_compare) adaptive_spr_results = results.Results( adaptive_spr.result_file_path, parameters=('fake period', 'temp fake duration', 'pr(tfs)', 'pr(pfs)'), results=results_to_compare) result_table = comparison.ResultTable(adaptive_spr_results, our_results) self._create_table("{}-{}-comparison".format(self.algorithm_module.name, adaptive_spr.name), result_table)
def _run_table(self, args): phantom_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=('normal latency', 'ssd', 'captured', 'sent', 'received ratio')) result_table = fake_result.ResultTable(phantom_results) self._create_table("{}-results".format(self.algorithm_module.name), result_table)
def transform(self, result_names): return [ results.Results( module.result_file_path, parameters=module.local_parameter_names, results=result_names) for module in self.algorithm_modules ]
def _run_table(self, args): adaptive_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=('normal latency', 'ssd', 'attacker distance')) result_table = fake_result.ResultTable(adaptive_results) self._create_table(self.algorithm_module.name + "-results", result_table)
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 _run_table(self, args): selected_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=('normal latency', 'ssd', 'captured', 'fake', 'received ratio', 'tfs')) result_table = fake_result.ResultTable(selected_results) self._create_table(self.algorithm_module.name + "-results", result_table)
def _run_table(self, args): phantom_walkabouts_results = results.Results( args.sim, self.algorithm_module.result_file_path(args.sim), parameters=self.algorithm_module.local_parameter_names, results=('normal latency', 'ssd', 'captured', 'sent', 'received ratio')) result_table = fake_result.ResultTable(phantom_walkabouts_results) self._create_table("{}-results".format(self.algorithm_module.name), result_table, orientation='landscape', show=args.show)
def _run_table(self, args): protectionless_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=('sent', 'norm(norm(sent,time taken),network size)', 'normal latency', 'captured', 'received ratio')) fmt = TableDataFormatter(convert_to_stddev=args.show_stddev) result_table = fake_result.ResultTable(protectionless_results, fmt) self._create_table(self.algorithm_module.name + "-results", result_table, show=args.show)
def _run_table(self, args): template_results = results.Results( args.sim, self.algorithm_module.result_file_path(args.sim), parameters=self.algorithm_module.local_parameter_names, results=('normal latency', 'ssd', 'captured', 'fake', 'received ratio', 'tfs', 'pfs')) result_table = fake_result.ResultTable(template_results) self._create_table(self.algorithm_module.name + "-results", result_table, show=args.show, param_filter=lambda fp, dur, ptfs, ppfs: ptfs not in {0.2, 0.3, 0.4})
def _run_table(self, args): adaptive_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=( #'sent', 'time taken', 'normal latency', 'ssd', 'captured', 'fake', 'dummy normal', 'received ratio', 'tfs', 'pfs', 'tailfs' #'norm(sent,time taken)', 'norm(norm(sent,time taken),network size)', #'norm(norm(norm(sent,time taken),network size),source rate)' )) result_table = fake_result.ResultTable(adaptive_results) self._create_table(self.algorithm_module.name + "-results", result_table)
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 __init__(self, sim_name, result_file, tafn_to_safety_period, fmt=None): self._sim_name = sim_name self._result_names = ('received ratio', 'normal latency', 'ssd', 'captured', 'time after first normal', 'repeats') self._results = results.Results( sim_name, result_file, parameters=tuple(), results=self._result_names ) self.tafn_to_safety_period = tafn_to_safety_period self.fmt = fmt if fmt is None: from data.table.data_formatter import TableDataFormatter self.fmt = TableDataFormatter()
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_table(self, args): adaptive_results = results.Results( args.sim, self.algorithm_module.result_file_path(args.sim), parameters=self.algorithm_module.local_parameter_names, results=( #'sent', #'norm(norm(sent,time taken),network size)', 'norm(norm(fake,time taken),network size)', 'delivered', 'time taken', 'captured', 'received ratio', #'ssd', 'attacker distance', 'fake nodes at end', 'fake nodes at end when captured')) result_table = fake_result.ResultTable(adaptive_results) self._create_table(self.algorithm_module.name + "-results", result_table, show=args.show)
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 _run_table(self, args): protectionless_results = results.Results( self.algorithm_module.result_file_path, parameters=self.algorithm_module.local_parameter_names, results=( 'sent', 'delivered', 'time taken', #'energy impact', #'energy impact per node', 'energy impact per node per second', 'norm(norm(sent,time taken),num_nodes)', 'normal latency', 'ssd', 'attacker distance', )) fmt = TableDataFormatter(convert_to_stddev=args.show_stddev) result_table = fake_result.ResultTable(protectionless_results, fmt) self._create_table(self.algorithm_module.name + "-results", result_table, show=args.show)
def _load_existing_results(self, argument_names): print("Loading existing results...") results_file_path = self.algorithm_module.result_file_path( self.sim_name) try: results_summary = results.Results( self.sim_name, results_file_path, parameters=argument_names[len(self._global_parameter_names):], results=('repeats', )) # (size, config, attacker_model, noise_model, communication_model, distance, period) -> repeats self._existing_results = { tuple(map(str, k)): v for (k, v) in results_summary.parameter_set().items() } except IOError as e: message = str(e) if 'No such file or directory' in message: raise RuntimeError( f"The results file {results_file_path} is not present. Perhaps rerun the command with '--no-skip-complete'?" ) else: raise
def __init__(self, data, style=STYLE_DEFAULT, *args, **kwds): # init wx.Dialog if style == STYLE_DEFAULT: kwds["style"] = wx.DEFAULT_DIALOG_STYLE elif style == STYLE_AUTO_START_CLOSE: kwds["style"] = wx.THICK_FRAME else: assert False wx.Dialog.__init__(self, *args, **kwds) # get parameters self.data = data self.style = style self.log = None self.docs = None self.results = None self.start = None self.stop = None if style == STYLE_DEFAULT: self.SetTitle("Script Runner") self.start = wx.Button(self, -1, "Start") self.stop = wx.Button(self, -1, "Stop") elif style == STYLE_AUTO_START_CLOSE: self.stop = wx.Button(self, -1, "Stop") else: assert False # bind event if self.stop is not None: self.Bind(wx.EVT_BUTTON, self.onStop, self.stop) if self.start is not None: self.Bind(wx.EVT_BUTTON, self.onStart, self.start) self.Bind(wx.EVT_CLOSE, self.onClose) # timer for activity gauge # self.Bind(wx.EVT_TIMER, self.handler_timer) # self.timer = wx.Timer(self) # process management self.process = None self.pid = None self.exit_code = None self.Bind(wx.EVT_END_PROCESS, self.OnProcessEnded) EVT_CUSTOM_STARTPROCESS(self, self.OnStartProcess) EVT_CUSTOM_ENDSCRIPTS(self, self.OnEndScripts) EVT_CUSTOM_EXECSTATUS(self, self.on_execstatus) # scripts runner self.evtScriptRun = threading.Event() self.evtReaderRun = threading.Event() self.thdScriptRun = threading.Thread(target=self.thread_scripts_runner, name="scripts_runner") if self.data[RUN_TYPE] == RUN_SCRIPT: self.results = dres.Results("tmp_controler") elif self.data[RUN_TYPE] == RUN_DOC: self.docs = ddoc.Documentation() else: raise Exception("No type run define") # create control self.lstboxScript = wx.ListBox(self, -1, size=wx.Size(400, 200)) self.lstboxScript.SetFont( wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL)) self.activity = wx.Gauge(self, -1, size=wx.Size(400, 30)) sizer_1 = wx.BoxSizer(wx.VERTICAL) sizer_1.Add((400, 20), 0, 0, 0) sizer_1.Add(self.lstboxScript, 0, wx.ALL, 5) sizer_1.Add(self.activity, 0, wx.ALL, 5) sizer_1.Add((400, 20), 0, 0, 0) if self.start is not None: sizer_1.Add( self.start, 0, wx.ALL | wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL, 5) if self.stop is not None: sizer_1.Add( self.stop, 0, wx.ALL | wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL, 5) self.SetSizer(sizer_1) sizer_1.Fit(self) self.Layout() self.init_GUI() # Start if style == STYLE_DEFAULT: pass elif style == STYLE_AUTO_START_CLOSE: self.start_running_script() else: assert False
def __init__(self, name, *p, **pp): wx.Panel.__init__(self, *p, **pp) self.tree = wx.TreeCtrl(self,-1) self.tree.SetFont(wx.Font(10, wx.FONTFAMILY_MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL)) self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate, self.tree) self.Bind(wx.EVT_TREE_ITEM_MENU, self.OnItemMenu, self.tree) il = wx.ImageList(16, 16) self.im_script = il.Add( wx.Bitmap("images/script.png", wx.BITMAP_TYPE_PNG)) self.im_pool = il.Add( wx.Bitmap("images/database.png", wx.BITMAP_TYPE_PNG)) self.im_folder = il.Add( wx.Bitmap("images/folder_database.png", wx.BITMAP_TYPE_PNG)) self.im_project = il.Add( wx.Bitmap("images/application_view_tile.png", wx.BITMAP_TYPE_PNG)) self.im_script_ko = il.Add( wx.Bitmap("images/script_delete.png", wx.BITMAP_TYPE_PNG)) self.im_script_warn = il.Add( wx.Bitmap("images/script_error.png", wx.BITMAP_TYPE_PNG)) self.im_script_ok = il.Add( wx.Bitmap("images/script_go.png", wx.BITMAP_TYPE_PNG)) self.im_result = il.Add( wx.Bitmap("images/table_multiple.png", wx.BITMAP_TYPE_PNG)) self.im_case_ok = il.Add( wx.Bitmap("images/bullet_green.png", wx.BITMAP_TYPE_PNG)) self.im_case_ko = il.Add( wx.Bitmap("images/bullet_red.png", wx.BITMAP_TYPE_PNG)) self.im_case = il.Add( wx.Bitmap("images/bullet_purple.png", wx.BITMAP_TYPE_PNG)) self.il = il self.tree.SetImageList(il) self.lst_res = list() self.lst_dest = list() self.sel_item = None self.log = None self.path = None self.wildcard_dbm = "Project file (*.dbm)|*.dbm|All files (*.*)|*.*" self.wildcard_csv = "Csv file (*.csv)|*.csv|All files (*.*)|*.*" self.res = dres.Results(name) self.update() # toolbar tsize = (16,16) self.tb1 = wx.ToolBar(self, -1) self.tb1.SetToolBitmapSize(tsize) bmp_new = wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, tsize) bmp_save = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE, wx.ART_TOOLBAR, tsize) bmp_saveas = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE_AS, wx.ART_TOOLBAR, tsize) bmp_open = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize) bmp_export_csv = wx.Bitmap("images/page_white_c.png", wx.BITMAP_TYPE_PNG) id_new = wx.NewId() id_save = wx.NewId() id_saveas = wx.NewId() id_open = wx.NewId() id_export_csv = wx.NewId() self.tb1.AddLabelTool(id_new, "New", bmp_new,) self.tb1.AddSeparator() self.tb1.AddLabelTool(id_open, "Open", bmp_open) self.tb1.AddLabelTool(id_save, "Save", bmp_save) self.tb1.AddLabelTool(id_saveas, "Save As", bmp_saveas) self.tb1.AddSeparator() self.tb1.AddLabelTool(id_export_csv,"Export csv", bmp_export_csv) self.tb1.SetToolShortHelp(id_new, "New result") self.tb1.SetToolShortHelp(id_open, "Open a result") self.tb1.SetToolShortHelp(id_save, "Save curent result") self.tb1.SetToolShortHelp(id_saveas, "Save As curent result") self.tb1.SetToolShortHelp(id_export_csv,"Export to csv") self.Bind(wx.EVT_TOOL, self.on_tool_new, id=id_new) self.Bind(wx.EVT_TOOL, self.on_tool_open, id=id_open) self.Bind(wx.EVT_TOOL, self.on_tool_save, id=id_save) self.Bind(wx.EVT_TOOL, self.on_tool_saveas, id=id_saveas) self.Bind(wx.EVT_TOOL, self.on_tool_csv, id=id_export_csv) self.tb1.Realize() # sizer sizer_1 = wx.BoxSizer(wx.VERTICAL) sizer_1.Add(self.tb1, 0, wx.ALL, 2) sizer_1.Add(self.tree, 1, wx.ALL| wx.EXPAND, 2) self.SetSizer(sizer_1) sizer_1.Fit(self) self.Layout()
def _run_min_max_versus(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), # 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'right top'), # 'normal': ('Normal Messages Sent', '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': ('Attacker-Source Distance (meters)', 'left top'), "attacker distance percentage": ('Normalised Attacker Distance (%)', 'left top'), #'norm(sent,time taken)': ('Messages Sent per Second', 'left top'), #'norm(fake,time taken)': ('Messages Sent per Second', 'left top'), 'norm(norm(sent,time taken),network size)': ('Messages Sent per Second per Node', 'left top'), 'norm(norm(fake,time taken),network size)': ('Fake Messages Sent per Second per node', 'left top'), # 'norm(normal,time taken)': ('Messages Sent per Second', 'left top'), # 'norm(norm(fake,time taken),source rate)': ('~', 'left top'), } custom_yaxis_range_max = { 'captured': 15, 'received ratio': 100, 'attacker distance': 160, 'normal latency': 120, 'norm(norm(sent,time taken),network size)': 15, 'norm(norm(fake,time taken),network size)': 15, } def filter_params(all_params): return (all_params['source period'] == '0.125' or all_params['noise model'] == 'meyer-heavy' or all_params['configuration'] != 'SourceCorner') def adaptive_filter_params(all_params): return filter_params(all_params) or all_params['approach'] in { "PB_SINK_APPROACH", "PB_ATTACKER_EST_APPROACH" } protectionless_analysis = protectionless.Analysis.Analyzer( args.sim, protectionless.results_path(args.sim)) protectionless_results = results.Results( args.sim, protectionless.result_file_path(args.sim), parameters=protectionless.local_parameter_names, results=list( set(graph_parameters.keys()) & set(protectionless_analysis.results_header().keys())), results_filter=filter_params) adaptive_spr_notify_results = results.Results( args.sim, self.algorithm_module.result_file_path(args.sim), parameters=self.algorithm_module.local_parameter_names, results=graph_parameters.keys(), results_filter=filter_params) adaptive_results = results.Results( args.sim, adaptive.result_file_path(args.sim), parameters=adaptive.local_parameter_names, results=graph_parameters.keys(), results_filter=adaptive_filter_params) template_results = results.Results( args.sim, template.result_file_path(args.sim), parameters=template.local_parameter_names, results=graph_parameters.keys(), results_filter=filter_params) 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() for result_name in graph_parameters.keys(): graph_min_max_versus(result_name, 'network size')
def _run_min_max_ilp_versus(self, args): graph_parameters = { 'normal latency': ('Normal Message Latency (ms)', 'left top'), # 'ssd': ('Sink-Source Distance (hops)', 'left top'), 'captured': ('Capture Ratio (%)', 'right top'), # 'normal': ('Normal Messages Sent', 'left top'), 'sent': ('Total Messages Sent', 'left top'), 'received ratio': ('Receive Ratio (%)', 'left bottom'), 'attacker distance': ('Attacker-Source 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'), # 'norm(normal,time taken)': ('Messages Sent per Second', 'left top'), } custom_yaxis_range_max = { 'captured': 25, 'received ratio': 100, 'attacker distance': 120, 'normal latency': 4000, 'norm(sent,time taken)': 8000, 'norm(norm(sent,time taken),network size)': 15, } def filter_params(all_params): return (all_params['source period'] == '0.125' or all_params['noise model'] == 'meyer-heavy' or all_params['configuration'] != 'SourceCorner') def adaptive_filter_params(all_params): return filter_params(all_params) or all_params['approach'] in { "PB_SINK_APPROACH", "PB_ATTACKER_EST_APPROACH" } def ilprouting_filter_params(all_params): return filter_params( all_params) or all_params["pr direct to sink"] != "0.2" protectionless_analysis = protectionless.Analysis.Analyzer( args.sim, protectionless.results_path(args.sim)) protectionless_results = results.Results( args.sim, protectionless.result_file_path(args.sim), parameters=protectionless.local_parameter_names, results=list( set(graph_parameters.keys()) & set(protectionless_analysis.results_header().keys())), results_filter=filter_params) adaptive_spr_notify_results = results.Results( args.sim, self.algorithm_module.result_file_path(args.sim), parameters=self.algorithm_module.local_parameter_names, results=graph_parameters.keys(), results_filter=filter_params) adaptive_results = results.Results( args.sim, adaptive.result_file_path(args.sim), parameters=adaptive.local_parameter_names, results=graph_parameters.keys(), results_filter=adaptive_filter_params) ilprouting_results = results.Results( args.sim, ilprouting.result_file_path(args.sim), parameters=ilprouting.local_parameter_names, results=graph_parameters.keys(), results_filter=ilprouting_filter_params) sim = submodule_loader.load(simulator.sim, args.sim) 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() for result_name in graph_parameters.keys(): graph_min_max_versus(result_name, 'network size')
def all_results(algorithms): modules = [algorithm.import_algorithm(algo) for algo in algorithms] module_results = [ results.Results(module.result_file_path, parameters=module.local_parameter_names, results=result_names) for module in modules ] for (name, module_result) in zip(algorithms, module_results): safety_factor_indexes[name] = module_result.parameter_names.index( "safety factor") parameters = {} for result in module_results: parameters.update(dict(result.parameters())) parameters_to_remove = [k for (k, v) in parameters.items() if len(v) == 1] new_global_parameters = tuple([ name for name in global_parameter_names[:-1] if name not in parameters_to_remove ]) results_data = [ transform_results_data(result.data, parameters_to_remove) for result in module_results ] combined_data = {} for (algo_name, result_data) in zip(algorithms, results_data): safety_factor_idx = safety_factor_indexes[algo_name] for (global_params, items1) in result_data.items(): if global_params not in combined_data: combined_data[global_params] = {} for (source_period, items2) in items1.items(): if source_period not in combined_data[global_params]: combined_data[global_params][source_period] = {} for (local_params, algo_results) in items2.items(): safety_factor = local_params[safety_factor_idx] if safety_factor not in combined_data[global_params][ source_period]: combined_data[global_params][source_period][ safety_factor] = {} new_local_params = transform_key(local_params, safety_factor_idx) combined_data[global_params][source_period][safety_factor][ (algo_name, new_local_params)] = algo_results return new_global_parameters, combined_data