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