def main(args):
parser = argparse.ArgumentParser()
parser.add_argument(
'--input-file',
dest='input_files',
nargs=2,
action='append',
required=True,
help="csv file to plot. Needs a label as a second argument.")
parser.add_argument('--window-size',
nargs=2,
action='append',
dest='window_size',
help="How long to average over. In ps.",
required=True)
parser.add_argument('--keep-temps',
dest='keep_temps',
default=False,
action='store_true',
help="Keep temp files")
parser.add_argument(
'--server',
dest='server_ip',
required=True,
help="IP of the machine that the card is directory connected to")
parser.add_argument('--output-name', dest='output_name', required=True)
parser.add_argument('--title', dest='title')
# This is to avoid issues with tcpdump hanging.
parser.add_argument('--packets',
type=int,
required=False,
default=None,
dest='packets',
help="Number of packets to process from a pcap file")
args = parser.parse_args(args)
plt.figure(1)
plt.clf()
plt.figure(2)
plt.clf()
plt.figure(3)
plt.clf()
plt.figure(4)
plt.clf()
for pcap_file, label in args.input_files:
for window_size, label_suffix in args.window_size:
if pcap_file.endswith('.csv'):
incoming_x_values, incoming_bandwidths = \
process_csv.extract_bandwidths(pcap_file, window_size,
to_ip=args.server_ip, count=args.packets)
outgoing_x_values, outgoing_bandwidths = \
process_csv.extract_bandwidths(pcap_file, window_size,
from_ip=args.server_ip, count=args.packets)
for i in range(len(incoming_bandwidths)):
incoming_bandwidths[i] = float(incoming_bandwidths[i])
# Dump the percentiles into a file.
percentiles = np.linspace(0.0, 1.0, 10000)
sorted_bandwidths = [
x for x in sorted(incoming_bandwidths) if x > 0.0
]
sorted_out_bandwidths = [
x for x in sorted(outgoing_bandwidths) if x > 0.0
]
with open(pcap_file + label_suffix + '.in_percentiles',
'w') as in_file:
with open(pcap_file + label_suffix + '.out_percentiles',
'w') as out_file:
contents_in = []
contents_out = []
count_in = len(sorted_bandwidths) - 1
count_out = len(sorted_out_bandwidths) - 1
for percentile in percentiles:
fraction_through_in = int(percentile * count_in)
fraction_through_out = int(percentile * count_out)
contents_in.append(
str(percentile) + ' ' + '{0:.15f}'.format(
sorted_bandwidths[fraction_through_in]) + '\n')
contents_out.append(
str(percentile) + ' ' + '{0:.15f}'.format(
sorted_out_bandwidths[fraction_through_out]) +
'\n')
in_file.writelines(contents_in)
out_file.writelines(contents_out)
min_lim = min(incoming_bandwidths)
max_lim = max(incoming_bandwidths)
small_diff = (min_lim + max_lim) / 10000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000),
np.inf)
print bins
plt.figure(1)
plt.hist(incoming_bandwidths,
cumulative=True,
bins=bins,
histtype='step',
normed=True,
label=label + ' ' + label_suffix)
no_zero_incoming_bandwidths = graph_utils.no_zeroes(
incoming_bandwidths)
if len(no_zero_incoming_bandwidths) > 0:
min_lim = min(no_zero_incoming_bandwidths)
max_lim = max(no_zero_incoming_bandwidths)
logspace_bins = graph_utils.get_logspace(min_lim, max_lim)
plt.figure(2)
plt.hist(no_zero_incoming_bandwidths,
cumulative=True,
bins=logspace_bins,
histtype='step',
normed=True,
label=label + ' ' + label_suffix)
else:
print "Error: No non-zero bandwidths found"
for i in range(len(outgoing_bandwidths)):
outgoing_bandwidths[i] = float(outgoing_bandwidths[i])
min_lim = min(outgoing_bandwidths)
max_lim = max(outgoing_bandwidths)
small_diff = (min_lim + max_lim) / 10000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000),
np.inf)
plt.figure(3)
plt.hist(outgoing_bandwidths,
cumulative=True,
bins=bins,
histtype='step',
normed=True,
label=label + ' ' + label_suffix)
no_zero_outgoing_bandwidths = graph_utils.no_zeroes(
outgoing_bandwidths)
if len(no_zero_outgoing_bandwidths) > 0:
min_lim = min(no_zero_outgoing_bandwidths)
max_lim = max(no_zero_outgoing_bandwidths)
logspace_bins = graph_utils.get_logspace(min_lim, max_lim)
plt.figure(4)
plt.hist(no_zero_outgoing_bandwidths,
cumulative=True,
bins=logspace_bins,
histtype='step',
normed=True,
label=label + ' ' + label_suffix)
else:
print "Error: No non-zero bandwidths found!"
if args.title:
plt.figure(1)
plt.title('Client Traffic: ' + args.title)
plt.figure(2)
plt.title('Client Traffic: ' + args.title)
plt.figure(3)
plt.title('Server Traffic: ' + args.title)
plt.figure(4)
plt.title('Server Traffic: ' + args.title)
label_count = len(args.input_files) * len(args.window_size)
graph_utils.latexify(bottom_label_rows=label_count / 2)
plt.figure(1)
plt.xlabel("Bandwidth (Mbps)")
plt.ylabel("CDF")
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_incoming_bandwidth_cdf_window.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(2)
plt.ylabel("CDF")
plt.xlabel("Bandwidth (Mbps)")
graph_utils.set_log_x()
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_incoming_bandwidth_cdf_window_log.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(3)
plt.xlabel("Bandwidth (Mbps)")
plt.ylabel("CDF")
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_outgoing_bandwidth_cdf_window.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(4)
plt.xlabel("Bandwidth (Mbps)")
plt.ylabel("CDF")
graph_utils.set_legend_below()
graph_utils.set_log_x()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_outgoing_bandwidth_cdf_window_log.eps'
plt.savefig(filename)
print "Done! File is in ", filename
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument(
'--input-file',
dest='input_files',
nargs=2,
action='append',
required=True,
help="csv file to plot. Needs a label as a second argument.")
parser.add_argument('--keep-temps',
dest='keep_temps',
default=False,
action='store_true',
help="Keep temp files")
parser.add_argument('--output-name', dest='output_name', required=True)
parser.add_argument('--title', dest='title')
# This is to avoid issues with tcpdump hanging.
parser.add_argument('--packets',
type=int,
required=False,
default=None,
dest='packets',
help="Number of packets to process from a pcap file")
args = parser.parse_args(args)
plt.figure(1)
plt.clf()
plt.figure(2)
plt.clf()
for pcap_file, label in args.input_files:
if pcap_file.endswith('.csv'):
flow_lengths = \
process_csv.extract_flow_lengths(pcap_file)
if len(flow_lengths) == 0:
print "There were no TCP connections detected in ", pcap_file
continue
for i in range(len(flow_lengths)):
flow_lengths[i] = float(flow_lengths[i])
min_lim = min(flow_lengths)
max_lim = max(flow_lengths)
small_diff = (min_lim + max_lim) / 1000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000),
np.inf)
plt.figure(1)
plt.hist(flow_lengths,
cumulative=True,
bins=bins,
histtype='step',
normed=True,
label=label)
no_zero_values = graph_utils.no_zeroes(flow_lengths)
if len(no_zero_values) > 0:
min_lim = min(no_zero_values)
max_lim = max(no_zero_values)
logspace_bins = graph_utils.get_logspace(min_lim, max_lim)
plt.figure(2)
plt.hist(no_zero_values,
cumulative=True,
bins=logspace_bins,
histtype='step',
normed=True,
label=label)
else:
print "Hard Warning!: Found no non-zero flow sizes"
if args.title:
plt.figure(1)
plt.title(args.title)
plt.figure(2)
plt.title(args.title)
label_count = len(args.input_files)
graph_utils.latexify(bottom_label_rows=label_count / 2)
plt.figure(1)
plt.xlabel("Flow Completion Time (s)")
plt.ylabel("CDF")
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_flow_lengths.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(2)
plt.xlabel("Flow Completion Time (s)")
plt.ylabel("CDF")
graph_utils.set_log_x()
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_flow_lengths_log.eps'
plt.savefig(filename)
print "Done! File is in ", filename
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument('--server',
dest='server_ip',
help="The IP address of the server",
required=False,
default=None)
parser.add_argument(
'--input-file',
dest='input_files',
nargs=2,
action='append',
required=True,
help="csv file to plot. Needs a label as a second argument.")
parser.add_argument('--keep-temps',
dest='keep_temps',
default=False,
action='store_true',
help="Keep temp files")
parser.add_argument('--output-name', dest='output_name', required=True)
parser.add_argument('--title', dest='title', required=False, default=None)
# This is to avoid issues with tcpdump hanging.
parser.add_argument('--packets',
type=int,
required=False,
default=None,
dest='packets',
help="Number of packets to process from a pcap file")
args = parser.parse_args(args)
plt.figure(1)
plt.clf()
plt.figure(2)
plt.clf()
plt.figure(3)
plt.clf()
plt.figure(4)
plt.clf()
for pcap_file, label in args.input_files:
if pcap_file.endswith('.csv'):
timestamp_deltas_incoming = \
process_csv.extract_deltas(pcap_file, to_ip=args.server_ip)
timestamp_deltas_outgoing = \
process_csv.extract_deltas(pcap_file, from_ip=args.server_ip)
# Convert to ns before starting:
for i in xrange(len(timestamp_deltas_incoming)):
timestamp_deltas_incoming[i] = float(
Decimal(1000000000.0) * timestamp_deltas_incoming[i])
for i in xrange(len(timestamp_deltas_outgoing)):
timestamp_deltas_outgoing[i] = float(
Decimal(1000000000.0) * timestamp_deltas_outgoing[i])
# Do the outgoing packets.
range = [
min(timestamp_deltas_outgoing),
max(timestamp_deltas_outgoing)
]
print "Range is ", range
print "Median is ", np.median(timestamp_deltas_outgoing)
print "Deviation is ", np.std(timestamp_deltas_outgoing)
timestamp_deltas_outgoing = \
np.asarray(timestamp_deltas_outgoing, dtype='float')
plt.figure(1)
min_lim = range[0]
max_lim = range[1]
small_diff = (min_lim + max_lim) / 10000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000),
np.inf)
plt.hist(timestamp_deltas_outgoing,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
timestamp_deltas_outgoing_no_zero = graph_utils.no_zeroes(
timestamp_deltas_outgoing)
if len(timestamp_deltas_outgoing_no_zero) > 0:
min_lim = min(timestamp_deltas_outgoing_no_zero)
max_lim = max(timestamp_deltas_outgoing_no_zero)
logspace_bins = graph_utils.get_logspace(min_lim, max_lim)
plt.figure(2)
plt.hist(timestamp_deltas_outgoing_no_zero,
bins=logspace_bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
# Do the incoming.
range = [
min(timestamp_deltas_incoming),
max(timestamp_deltas_incoming)
]
print "Incoming Range is ", range
print "Incoming Median is ", np.median(timestamp_deltas_incoming)
print "Incoming Deviation is ", np.std(timestamp_deltas_incoming)
timestamp_deltas_incoming = \
np.asarray(timestamp_deltas_incoming, dtype='float')
min_lim = range[0]
max_lim = range[1]
small_diff = (min_lim + max_lim) / 10000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000),
np.inf)
plt.figure(3)
plt.hist(timestamp_deltas_incoming,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
timestamp_deltas_incoming_no_zero = graph_utils.no_zeroes(
timestamp_deltas_incoming)
if len(timestamp_deltas_incoming_no_zero) > 0:
min_lim = min(timestamp_deltas_incoming_no_zero)
max_lim = max(timestamp_deltas_incoming_no_zero)
plt.figure(4)
plt.hist(timestamp_deltas_incoming,
bins=logspace_bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
else:
print "Error: found no incoming timestamp deltas with nonzero inter-arrival times"
if args.title:
plt.figure(1)
plt.title("Server Traffic: " + args.title)
plt.figure(2)
plt.title("Server Traffic: " + args.title)
plt.figure(3)
plt.title("Client Traffic: " + args.title)
plt.figure(4)
plt.title("Client Traffic: " + args.title)
label_count = len(args.input_files)
graph_utils.latexify(bottom_label_rows=label_count / 2)
plt.figure(1)
plt.ylabel("CDF")
plt.xlabel("Inter-arrival time (ns)")
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_outgoing_interarrival.eps'
plt.savefig(filename)
print "Done! File is in ", args.output_name + '_outgoing_interarrival'
plt.figure(2)
plt.ylabel("CDF")
plt.xlabel("Inter-arrival time (ns)")
graph_utils.set_legend_below()
graph_utils.set_log_x()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
filename = args.output_name + '_outgoing_interarrival_log.eps'
plt.savefig(filename)
print "Done! File is in ", args.output_name + '_outgoing_interarrival'
# Do the incoming packets.
plt.figure(3)
plt.ylabel("CDF")
graph_utils.set_legend_below()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
plt.xlabel("Inter-arrival time (ns)")
filename = args.output_name + '_incoming_interarrival.eps'
plt.savefig(filename)
print "Done! File is in ", args.output_name + '_incoming_interarrival'
# Do the incoming packets.
plt.figure(4)
plt.ylabel("CDF")
graph_utils.set_legend_below()
graph_utils.set_log_x()
graph_utils.set_yax_max_one()
graph_utils.set_non_negative_axes()
graph_utils.set_ticks()
plt.xlabel("Inter-arrival time (ns)")
filename = args.output_name + '_incoming_interarrival_log.eps'
plt.savefig(filename)
print "Done! File is in ", args.output_name + '_incoming_interarrival'
def main(args):
parser = argparse.ArgumentParser()
parser.add_argument(
'--input-file',
dest='input_files',
nargs=2,
action='append',
required=True,
help="csv file to plot. Needs a label as a second argument.")
parser.add_argument('--keep-temps',
dest='keep_temps',
default=False,
action='store_true',
help="Keep temp files")
parser.add_argument('--server', dest='server_ip', required=True)
parser.add_argument('--output-name', dest='output_name', required=True)
parser.add_argument('--title', dest='title', required=False, default=None)
# This is to avoid issues with tcpdump hanging.
parser.add_argument('--packets',
type=int,
required=False,
default=None,
dest='packets',
help="Number of packets to process from a pcap file")
args = parser.parse_args(args)
plt.figure(1)
plt.clf()
plt.figure(2)
plt.clf()
plt.figure(3)
plt.clf()
plt.figure(4)
plt.clf()
pcap_files = args.input_files
output_label = args.output_name
for (pcap_file, label) in pcap_files:
if pcap_file.endswith('.csv'):
incoming_ipg_gaps = \
process_csv.extract_ipgs(pcap_file, to_ip=args.server_ip)
outgoing_ipg_gaps = \
process_csv.extract_ipgs(pcap_file, from_ip=args.server_ip)
range = [min(incoming_ipg_gaps), max(incoming_ipg_gaps)]
print "Dealing with incoming IPG gaps"
print "Range is ", range
print "Median is ", np.median(incoming_ipg_gaps)
print "Deviation is ", np.std(incoming_ipg_gaps)
# Before we plot these, they need to be converted to normal
# floats. To do this, multiply by 10**9
for i in xrange(len(incoming_ipg_gaps)):
incoming_ipg_gaps[i] = float(
Decimal(1000000000.0) * incoming_ipg_gaps[i])
for i in xrange(len(outgoing_ipg_gaps)):
outgoing_ipg_gaps[i] = float(
Decimal(1000000000.0) * outgoing_ipg_gaps[i])
# Remove anything greater than the 99th percentile to stop
# if affecting the bins.
i = 0
nintyninth_percentile = np.percentile(incoming_ipg_gaps, 99)
while i < len(incoming_ipg_gaps):
if incoming_ipg_gaps[i] > nintyninth_percentile:
del incoming_ipg_gaps[i]
else:
i += 1
print nintyninth_percentile
# Avoid issues witht the CDF line decreasing to zero after the data is
# plotted.
min_lim = min(incoming_ipg_gaps)
max_lim = max(incoming_ipg_gaps)
small_diff = (min_lim + max_lim) / 10000.0
bins = np.linspace(min_lim, max_lim + small_diff, 1000)
bins = np.append(bins, np.inf)
plt.figure(1)
plt.hist(incoming_ipg_gaps,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
# Now plot a log space version, with all times included.
incoming_ipg_gas_no_zeroes = graph_utils.no_zeroes(incoming_ipg_gaps)
if len(incoming_ipg_gas_no_zeroes) > 0:
lim_min = min(incoming_ipg_gas_no_zeroes)
lim_max = max(incoming_ipg_gas_no_zeroes)
bins = graph_utils.get_logspace(lim_min, lim_max)
plt.figure(2)
plt.hist(incoming_ipg_gas_no_zeroes,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
else:
print "Error:: found only zero times on the incoming IPG gaps"
# Now do the outgoing.
# Remove anything greater than the 99th percentile to stop
# if affecting the bins.
i = 0
nintyninth_percentile = np.percentile(outgoing_ipg_gaps, 99)
while i < len(outgoing_ipg_gaps):
if outgoing_ipg_gaps[i] > nintyninth_percentile:
del outgoing_ipg_gaps[i]
else:
i += 1
print nintyninth_percentile
# Avoid issues witht the CDF line decreasing to zero after the data
# is plotted.
min_lim = min(outgoing_ipg_gaps)
max_lim = max(outgoing_ipg_gaps)
small_diff = (min_lim + max_lim) / 10000.0
bins = np.linspace(min_lim, max_lim + small_diff, 1000)
bins = np.append(bins, np.inf)
plt.figure(3)
plt.hist(outgoing_ipg_gaps,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
# Now plot the logspace version.
outgoing_ipg_gaps_no_zeroes = graph_utils.no_zeroes(outgoing_ipg_gaps)
if len(outgoing_ipg_gaps_no_zeroes) > 0:
min_lim = min(outgoing_ipg_gaps_no_zeroes)
max_lim = max(outgoing_ipg_gaps_no_zeroes)
bins = graph_utils.get_logspace(min_lim, max_lim)
plt.figure(4)
plt.hist(outgoing_ipg_gaps_no_zeroes,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
else:
print "Error: No non-zero IPGs found in outgoing data"
if args.title:
plt.figure(1)
plt.title('Client Traffic: ' + args.title)
plt.figure(2)
plt.title('Client Traffic: ' + args.title)
plt.figure(3)
plt.title('Server Traffic: ' + args.title)
plt.figure(4)
plt.title('Server Traffic: ' + args.title)
label_count = len(args.input_files)
graph_utils.latexify(bottom_label_rows=label_count / 2)
plt.figure(1)
plt.xlim([min(outgoing_ipg_gaps), nintyninth_percentile])
plt.ylabel("CDF")
plt.xlabel("Inter-Arrival Time (ns)")
graph_utils.set_legend_below()
graph_utils.set_non_negative_axes()
graph_utils.set_yax_max_one()
graph_utils.set_ticks()
filename = output_label + '_ipg_gaps_clients.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(2)
plt.ylabel("CDF")
plt.xlabel("Inter-Arrival Time (ns)")
graph_utils.set_legend_below()
graph_utils.set_log_x()
graph_utils.set_non_negative_axes()
graph_utils.set_yax_max_one()
graph_utils.set_ticks()
filename = output_label + '_ipg_gaps_clients_log.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(3)
plt.xlim([min(outgoing_ipg_gaps), nintyninth_percentile])
plt.ylabel("CDF")
plt.xlabel("Inter-Arrival Time (ns)")
graph_utils.set_legend_below()
graph_utils.set_non_negative_axes()
graph_utils.set_yax_max_one()
graph_utils.set_ticks()
filename = output_label + '_ipg_gaps_server.eps'
plt.savefig(filename)
print "Done! File is in ", filename
plt.figure(4)
plt.ylabel("CDF")
plt.xlabel("Inter-Arrival Time (ns)")
graph_utils.set_legend_below()
graph_utils.set_log_x()
graph_utils.set_non_negative_axes()
graph_utils.set_yax_max_one()
graph_utils.set_ticks()
filename = output_label + '_ipg_gaps_server_log.eps'
plt.savefig(filename)
print "Done! File is in ", filename
def microburst_analyze(bursts, identifier, pcap_file, label, id_base):
global max_xlims_burst_lengths
print identifier, " Number of bursts", len(bursts)
bins = 1000
if len(bursts) == 0:
return
# Print a CDF of the microburst length distribution:
lengths = [len(x) for x in bursts]
min_lim = min(lengths)
max_lim = max(lengths)
max_xlims_burst_lengths.append(max_lim)
small_diff = (min_lim + max_lim) / 10000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000), np.inf)
plt.figure(1 + id_base)
plt.hist(lengths,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
# Do the same, but with a log scale:
non_zero_lengths = graph_utils.no_zeroes(lengths)
if len(non_zero_lengths) > 0:
plt.figure(2 + id_base)
min_lim = min(non_zero_lengths)
max_lim = max(non_zero_lengths)
bins = graph_utils.get_logspace(min_lim, max_lim)
plt.hist(non_zero_lengths,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
# Plot a CDF of the bandwidth achieved in each microburst.
bandwidths = []
for burst in bursts:
start_time = burst[0].wire_start_time()
end_time = burst[len(burst) - 1].wire_end_time()
total_time_in_use = Decimal(
sum([packet.wire_length_time() for packet in burst]))
bandwidths.append(
Decimal(10000.0) * (total_time_in_use / (end_time - start_time)))
if MICROBURST_DEBUG:
for packet in burst:
print "Packet time is ", packet.wire_start_time()
print "Packet size is ", packet.length
print "Packet end time is ", packet.wire_end_time()
print "Time in use", total_time_in_use
print "Total time is ", end_time - start_time
print "Usage is ", bandwidths[-1]
for i in range(len(bandwidths)):
bandwidths[i] = float(bandwidths[i])
plt.figure(3 + id_base)
min_lim = min(bandwidths)
max_lim = max(bandwidths)
small_diff = (min_lim + max_lim) / 10000.0
bins = np.append(np.linspace(min_lim, max_lim + small_diff, 1000), np.inf)
plt.hist(bandwidths,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
# And do the logarithmic version.
non_zero_bandwidths = graph_utils.no_zeroes(bandwidths)
if len(non_zero_bandwidths) > 0:
min_lim = min(non_zero_bandwidths)
max_lim = max(non_zero_bandwidths)
bins = graph_utils.get_logspace(min_lim, max_lim)
plt.figure(4 + id_base)
plt.hist(non_zero_bandwidths,
bins=bins,
cumulative=True,
histtype='step',
normed=True,
label=label)
else:
print "There were non non-zero bandwidths!"