From 0fd472224d1185e03cd30368108ce201a05af633 Mon Sep 17 00:00:00 2001
From: Giovanni Grieco <giovanni@grieco.dev>
Date: Tue, 23 Apr 2024 09:23:32 +0200
Subject: [PATCH] analysis: refactor python scripts

---
 .../drone_peripheral_consumption_to_state.py  |  58 +++--
 analysis/geosnr.py                            |  66 +++---
 analysis/get_rssi.py                          |  40 ++--
 analysis/latency_lte.py                       | 137 ++++++------
 analysis/latency_wifi+lte.py                  | 187 ++++++++--------
 analysis/lte-split_MacUlStats_per_drone.py    |  44 ++--
 analysis/lte-split_RlcUlStats_per_drone.py    |  51 ++---
 analysis/lte-throughput_per_drone.py          |  66 +++---
 analysis/merge_trajectory_powerconsumption.py |  50 +++--
 analysis/niro.py                              | 110 +++++-----
 analysis/pcap-throughput_per_drone.py         |  56 ++---
 analysis/plr.py                               |  69 +++---
 analysis/plr2.py                              | 110 +++++-----
 analysis/plr_datarate.py                      | 202 +++++++++++-------
 analysis/plr_lte.py                           | 137 ++++++------
 analysis/plr_lte2.py                          |  46 ++--
 analysis/plr_wifi+lte.py                      | 176 +++++++--------
 analysis/preview.py                           |  88 ++++----
 analysis/progress.py                          |  53 ++---
 analysis/rem-2d-preview.py                    | 104 +++++----
 analysis/rem-3d-preview.py                    |  34 +--
 analysis/sinr_lte.py                          |  25 ++-
 analysis/sinr_wifi.py                         | 114 +++++-----
 analysis/trajectory+cellid.py                 |  63 +++---
 analysis/trajectory2csv.py                    |  50 +++--
 analysis/txt2ply.py                           |  30 +--
 26 files changed, 1144 insertions(+), 1022 deletions(-)

diff --git a/analysis/drone_peripheral_consumption_to_state.py b/analysis/drone_peripheral_consumption_to_state.py
index 50deb13..0912ff0 100755
--- a/analysis/drone_peripheral_consumption_to_state.py
+++ b/analysis/drone_peripheral_consumption_to_state.py
@@ -3,33 +3,55 @@
 from argparse import ArgumentParser
 from enum import Enum
 
-P = ArgumentParser(description='Given power law of a peripheral, convert a given CSV with peripheral power data to deduce its state.')
-P.add_argument('input_csv_filepath', type=str, help='Input CSV filepath containing peripheral power data.')
-P.add_argument('output_csv_filepath', type=str, help='Output CSV filepath to report peripheral state.')
-P.add_argument('off_state_power_W', type=float, help='Power consumption of the peripheral when in OFF state.')
-P.add_argument('on_state_power_W', type=float, help='Power consumption of the peripheral when in ON state.')
-P.add_argument('standby_state_power_W', type=float, help='Power consumption of the peripheral when in STANDBY state.')
+P = ArgumentParser(
+    description="Given power law of a peripheral, convert a given CSV with peripheral power data to deduce its state."
+)
+P.add_argument(
+    "input_csv_filepath",
+    type=str,
+    help="Input CSV filepath containing peripheral power data.",
+)
+P.add_argument(
+    "output_csv_filepath",
+    type=str,
+    help="Output CSV filepath to report peripheral state.",
+)
+P.add_argument(
+    "off_state_power_W",
+    type=float,
+    help="Power consumption of the peripheral when in OFF state.",
+)
+P.add_argument(
+    "on_state_power_W",
+    type=float,
+    help="Power consumption of the peripheral when in ON state.",
+)
+P.add_argument(
+    "standby_state_power_W",
+    type=float,
+    help="Power consumption of the peripheral when in STANDBY state.",
+)
 args = P.parse_args()
 
 peripheral_state = {
-  args.off_state_power_W: 'OFF',
-  args.on_state_power_W: 'ON',
-  args.standby_state_power_W: 'STANDBY'
+    args.off_state_power_W: "OFF",
+    args.on_state_power_W: "ON",
+    args.standby_state_power_W: "STANDBY",
 }
 
-inf = open(args.input_csv_filepath, 'r')
+inf = open(args.input_csv_filepath, "r")
 inr = csv.reader(inf)
-next(inr) # ignore header
+next(inr)  # ignore header
 
-outf = open(args.output_csv_filepath, 'w')
-outw = csv.writer(outf, lineterminator='\n')
-outw.writerow(['time','state'])
+outf = open(args.output_csv_filepath, "w")
+outw = csv.writer(outf, lineterminator="\n")
+outw.writerow(["time", "state"])
 
 for r in inr:
-  t = float(r[0])
-  p = float(r[1])
-  s = peripheral_state[p]
-  outw.writerow([t,s])
+    t = float(r[0])
+    p = float(r[1])
+    s = peripheral_state[p]
+    outw.writerow([t, s])
 
 inf.close()
 outf.close()
diff --git a/analysis/geosnr.py b/analysis/geosnr.py
index 9c1dbcd..29dceda 100644
--- a/analysis/geosnr.py
+++ b/analysis/geosnr.py
@@ -1,61 +1,57 @@
-#%%
+# %%
 from pathlib import Path
 
 import pandas as pd
-import plotly.graph_objects as go
 import plotly.express as px
+import plotly.graph_objects as go
 
-#%% Helper functions
+
+# %% Helper functions
 def get_seed_name(x):
-  # param x: Path object
-  return int(x.name.split('-')[1].split('_')[1])
+    # param x: Path object
+    return int(x.name.split("-")[1].split("_")[1])
+
 
-#%%
-results_path = Path('../results')
-results = [x for x in results_path.iterdir() if x.is_dir() and x.name.startswith('ntn_hap-seed')]
+# %%
+results_path = Path("../results")
+results = [
+    x
+    for x in results_path.iterdir()
+    if x.is_dir() and x.name.startswith("ntn_hap-seed")
+]
 
 # Expected format: ntn_hap-seed_<seed>-<date>.<time>
 results.sort(key=get_seed_name)
 
-#%%
-traces = [x / 'ntn-snr-trace.txt' for x in results]
+# %%
+traces = [x / "ntn-snr-trace.txt" for x in results]
 
 # Read traces and store in a dataframe
 df = pd.DataFrame()
 
 for trace in traces:
-  temp_df = pd.read_csv(trace, sep=' ', header=None, names=['time', 'snr', 'propagationLoss'])
-  df = pd.concat((df, temp_df), axis=1)
+    temp_df = pd.read_csv(
+        trace, sep=" ", header=None, names=["time", "snr", "propagationLoss"]
+    )
+    df = pd.concat((df, temp_df), axis=1)
 
-mean_snr = df[['snr']].mean(axis=1)
-mean_propagation_loss = df[['propagationLoss']].mean(axis=1)
+mean_snr = df[["snr"]].mean(axis=1)
+mean_propagation_loss = df[["propagationLoss"]].mean(axis=1)
 
-#%%
+# %%
 # plot SNR
 fig = go.Figure()
-fig.add_trace(go.Scatter(
-  y=mean,
-  mode='lines',
-  name='SNR'
-))
-fig.update_layout(
-  title='SNR',
-  xaxis_title='Time (s)',
-  yaxis_title='SNR (dB)'
-)
+fig.add_trace(go.Scatter(y=mean, mode="lines", name="SNR"))
+fig.update_layout(title="SNR", xaxis_title="Time (s)", yaxis_title="SNR (dB)")
 fig.show()
 
-#%%
+# %%
 # plot propagation loss
 fig = go.Figure()
-fig.add_trace(go.Scatter(
-  y=mean_propagation_loss,
-  mode='lines',
-  name='PropagationLoss (dB)'
-))
+fig.add_trace(
+    go.Scatter(y=mean_propagation_loss, mode="lines", name="PropagationLoss (dB)")
+)
 fig.update_layout(
-  title='Propagation Loss',
-  xaxis_title='Time (s)',
-  yaxis_title='PropagationLoss (dB)'
+    title="Propagation Loss", xaxis_title="Time (s)", yaxis_title="PropagationLoss (dB)"
 )
-fig.show()
\ No newline at end of file
+fig.show()
diff --git a/analysis/get_rssi.py b/analysis/get_rssi.py
index 5d09685..fef2ec9 100755
--- a/analysis/get_rssi.py
+++ b/analysis/get_rssi.py
@@ -6,31 +6,37 @@
 
 # TODO -- this script does not work, yet
 
-P = ArgumentParser(description='Retrieve RSSI measurements from summary XML file and export them in separate CSVs, '
-                               'one per drone.')
-P.add_argument('summary_filepath', type=str, help='Input summary XML file of the scenario.')
+P = ArgumentParser(
+    description="Retrieve RSSI measurements from summary XML file and export them in separate CSVs, "
+    "one per drone."
+)
+P.add_argument(
+    "summary_filepath", type=str, help="Input summary XML file of the scenario."
+)
 args = P.parse_args()
 
 base_path = PurePath(args.summary_filepath).parent
-output_prefix = 'rssi-drone'
+output_prefix = "rssi-drone"
 
 xmlroot = ET.parse(args.summary_filepath).getroot()
-zsp_addr = xmlroot.find('ZSPs').find('ZSP')
+zsp_addr = xmlroot.find("ZSPs").find("ZSP")
 print(zsp_addr)
-zsp_addr = zsp_addr.find('NetDevices').find('NetDevice').find('phy').find('address').text
+zsp_addr = (
+    zsp_addr.find("NetDevices").find("NetDevice").find("phy").find("address").text
+)
 
-drones = xmlroot.find('Drones').findall('Drone')
+drones = xmlroot.find("Drones").findall("Drone")
 i_drone = 0
 for d in drones:
-  for nd in d.find('NetDevices').findall('NetDevice'):
-    dtype = nd.find('type').text
-    if (dtype == 'ns3::WifiNetDevice'):
-      with open(f'{base_path}/{output_prefix}_{i_drone}.csv', 'w') as outf:
-        csvw = csv.writer(outf, lineterminator='\n')
-        csvw.writerow(['time', 'rssi'])
+    for nd in d.find("NetDevices").findall("NetDevice"):
+        dtype = nd.find("type").text
+        if dtype == "ns3::WifiNetDevice":
+            with open(f"{base_path}/{output_prefix}_{i_drone}.csv", "w") as outf:
+                csvw = csv.writer(outf, lineterminator="\n")
+                csvw.writerow(["time", "rssi"])
 
-        for s in nd.find('signal').findall('rssi'):
-          attrs = s.attrib
-          csvw.writerow([attrs['time'], attrs['value']])
+                for s in nd.find("signal").findall("rssi"):
+                    attrs = s.attrib
+                    csvw.writerow([attrs["time"], attrs["value"]])
 
-  i_drone += 1
+    i_drone += 1
diff --git a/analysis/latency_lte.py b/analysis/latency_lte.py
index 565f5d4..574c4fd 100644
--- a/analysis/latency_lte.py
+++ b/analysis/latency_lte.py
@@ -1,112 +1,111 @@
-#%%
+# %%
 import re
 
 import numpy as np
 import pandas as pd
 import plotly.express as px
 
-#%%
-base_results_dir = '../results/'
-scenario_name = 'paper_3-lte'
-scenario_datetime = '2022-03-15.16-53-33'
-internet_rx_trace_filename = 'internet-35-1.tr'
-scenario_dir = f'{scenario_name}-{scenario_datetime}'
-tx_trace_filename = 'paper_3-lte.log'
+# %%
+base_results_dir = "../results/"
+scenario_name = "paper_3-lte"
+scenario_datetime = "2022-03-15.16-53-33"
+internet_rx_trace_filename = "internet-35-1.tr"
+scenario_dir = f"{scenario_name}-{scenario_datetime}"
+tx_trace_filename = "paper_3-lte.log"
 
 lte_id2addr_offset = 2
 
-rex = re.compile(r'(?P<time>[0-9\.+]+)s (?P<nodeid>[0-9]+) .+ 200\.0\.0\.1 .+ '
-                 r'ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"(?P<time>[0-9\.+]+)s (?P<nodeid>[0-9]+) .+ 200\.0\.0\.1 .+ "
+    r"ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+"
+)
 
 tx_traces = {}
 pkts = []
 
-with open(f'{base_results_dir}/{scenario_dir}/{tx_trace_filename}', 'r') as f:
-  for l in f:
-    r = rex.match(l)
-    if r is not None:
-      ## DEBUG
-      # print(r[0])
-      # print(r.groupdict())
-      # break
-      ##
-      g = r.groupdict()
-      pkts.append({
-        'time': float(g['time']),
-        'nodeid': int(g['nodeid']),
-        'sn': int(g['sn'])
-      })
+with open(f"{base_results_dir}/{scenario_dir}/{tx_trace_filename}", "r") as f:
+    for l in f:
+        r = rex.match(l)
+        if r is not None:
+            ## DEBUG
+            # print(r[0])
+            # print(r.groupdict())
+            # break
+            ##
+            g = r.groupdict()
+            pkts.append(
+                {
+                    "time": float(g["time"]),
+                    "nodeid": int(g["nodeid"]),
+                    "sn": int(g["sn"]),
+                }
+            )
 
 for p in pkts:
-  lte_host_addr = f'7.0.0.{p["nodeid"] + lte_id2addr_offset}'
+    lte_host_addr = f'7.0.0.{p["nodeid"] + lte_id2addr_offset}'
 
-  if lte_host_addr in tx_traces:
-    tx_traces[lte_host_addr].append(p)
-  else:
-    tx_traces[lte_host_addr] = [p]
+    if lte_host_addr in tx_traces:
+        tx_traces[lte_host_addr].append(p)
+    else:
+        tx_traces[lte_host_addr] = [p]
 
 for k in tx_traces.keys():
-  tx_traces[k] = pd.DataFrame(tx_traces[k])
+    tx_traces[k] = pd.DataFrame(tx_traces[k])
 
 
-#%%
-ip_addrs = [f'7.0.0.{i}' for i in range(lte_id2addr_offset, len(tx_traces.keys()) + 1)]
+# %%
+ip_addrs = [f"7.0.0.{i}" for i in range(lte_id2addr_offset, len(tx_traces.keys()) + 1)]
 
-rex = re.compile(r'r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+'
-                 r' > 1337.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+"
+    r" > 1337.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+"
+)
 rx_traces = {k: [] for k in tx_traces.keys()}
 
-with open(f'{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}', 'r') as f:
-  for l in f:
-    r = rex.match(l)
-    if r is not None:
-      ## DEBUG
-      # print(r[0])
-      # print(r.groupdict())
-      # break
-      ##
-      g = r.groupdict()
-      host_addr = f'7.0.0.{g["lte_host_id"]}'
+with open(f"{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}", "r") as f:
+    for l in f:
+        r = rex.match(l)
+        if r is not None:
+            ## DEBUG
+            # print(r[0])
+            # print(r.groupdict())
+            # break
+            ##
+            g = r.groupdict()
+            host_addr = f'7.0.0.{g["lte_host_id"]}'
 
-      rx_traces[host_addr].append({
-        'time': float(g['time']),
-        'sn': int(g['sn'])
-      })
+            rx_traces[host_addr].append({"time": float(g["time"]), "sn": int(g["sn"])})
 
-rx_traces = {k: pd.DataFrame(v) for k,v in rx_traces.items()}
+rx_traces = {k: pd.DataFrame(v) for k, v in rx_traces.items()}
 
 
 # %%
 def to_latency(txdf, rxdf):
-  if txdf.empty or rxdf.empty:
-    return pd.Series({}, dtype=np.float64)
+    if txdf.empty or rxdf.empty:
+        return pd.Series({}, dtype=np.float64)
+
+    l = pd.merge(txdf, rxdf, on="sn")
+    return l["time_y"] - l["time_x"]
 
-  l = pd.merge(txdf, rxdf, on='sn')
-  return (l['time_y'] - l['time_x'])
 
-assert(tx_traces.keys() == rx_traces.keys())
-latency = {k: to_latency(tx_traces[k], rx_traces[k])
-           for k in tx_traces.keys()}
+assert tx_traces.keys() == rx_traces.keys()
+latency = {k: to_latency(tx_traces[k], rx_traces[k]) for k in tx_traces.keys()}
 
 # %% Export to MATLAB
-lat2matlab = {
-  'NodeID': [],
-  'latency': []
-}
+lat2matlab = {"NodeID": [], "latency": []}
 
 nodeid = 1
 for k in latency.keys():
-  for v in latency[k]:
-    lat2matlab['NodeID'].append(nodeid)
-    lat2matlab['latency'].append(v)
+    for v in latency[k]:
+        lat2matlab["NodeID"].append(nodeid)
+        lat2matlab["latency"].append(v)
 
-  nodeid += 1
+    nodeid += 1
 
-pd.DataFrame(lat2matlab).to_csv('./s3-latency_lte.csv')
+pd.DataFrame(lat2matlab).to_csv("./s3-latency_lte.csv")
 
 
 # %%
-fig = px.box(latency,
-             labels=dict(value='Latency [s]', variable='GU IP Address'))
+fig = px.box(latency, labels=dict(value="Latency [s]", variable="GU IP Address"))
 fig.show()
 # %%
diff --git a/analysis/latency_wifi+lte.py b/analysis/latency_wifi+lte.py
index d6301ad..1d3cbf2 100644
--- a/analysis/latency_wifi+lte.py
+++ b/analysis/latency_wifi+lte.py
@@ -1,149 +1,142 @@
-#%%
+# %%
 import re
 import socket
 
 import pandas as pd
 import plotly.graph_objects as go
 
-#%% Parameters configuration
-base_results_dir = '../results/'
-scenario_name = 'paper_3-wifi'
+# %% Parameters configuration
+base_results_dir = "../results/"
+scenario_name = "paper_3-wifi"
 # scenario_dir = f'{scenario_name}-2022-03-03.18-53-11'
-scenario_dir = f'{scenario_name}-2022-03-15.16-53-30'
+scenario_dir = f"{scenario_name}-2022-03-15.16-53-30"
 
-wifi_tx_trace_filenames = [f'wifi-phy-0-drones-host-{i}-0.log'
-                           for i in range(4,10)]
-wifi_tx_trace_filenames += [f'wifi-phy-1-drones-host-{i}-0.log'
-                            for i in range(10, 20)]
-wifi_tx_trace_filenames += [f'wifi-phy-2-drones-host-{i}-0.log'
-                            for i in range(20, 30)]
-wifi_tx_trace_filenames += [f'wifi-phy-3-drones-host-{i}-0.log'
-                            for i in range(30, 38)]
+wifi_tx_trace_filenames = [f"wifi-phy-0-drones-host-{i}-0.log" for i in range(4, 10)]
+wifi_tx_trace_filenames += [f"wifi-phy-1-drones-host-{i}-0.log" for i in range(10, 20)]
+wifi_tx_trace_filenames += [f"wifi-phy-2-drones-host-{i}-0.log" for i in range(20, 30)]
+wifi_tx_trace_filenames += [f"wifi-phy-3-drones-host-{i}-0.log" for i in range(30, 38)]
 
-internet_rx_trace_filename = 'internet-39-1.tr'
+internet_rx_trace_filename = "internet-39-1.tr"
 
 ##% Helper routines
 
+
 def custom_val_map(k, v):
-  if k == 'ipaddr':
-    return v
-  else:
-    return float(v)
+    if k == "ipaddr":
+        return v
+    else:
+        return float(v)
+
 
 ##%
-rex = re.compile(r't (?P<time>[0-9\.+]+).+HeMcs(?P<mcs>[0-9]+).+ (?P<ipaddr>[0-9\.]+) > 200\.0\.0\.1.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"t (?P<time>[0-9\.+]+).+HeMcs(?P<mcs>[0-9]+).+ (?P<ipaddr>[0-9\.]+) > 200\.0\.0\.1.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+"
+)
 
 tx_traces = []
 
 for fn in wifi_tx_trace_filenames:
-  pkts = []
+    pkts = []
 
-  with open(f'{base_results_dir}/{scenario_dir}/{fn}', 'r') as f:
-    for l in f:
-      r = rex.match(l)
+    with open(f"{base_results_dir}/{scenario_dir}/{fn}", "r") as f:
+        for l in f:
+            r = rex.match(l)
 
-      if r is not None:
-        ## DEBUG
-        # print(r[0])
-        # print(r.groupdict())
-        # break
-        ##
-        pkts.append({k: custom_val_map(k, v) for k,v in r.groupdict().items()})
+            if r is not None:
+                ## DEBUG
+                # print(r[0])
+                # print(r.groupdict())
+                # break
+                ##
+                pkts.append({k: custom_val_map(k, v) for k, v in r.groupdict().items()})
 
-  tx_traces.append(pd.DataFrame(pkts))
+    tx_traces.append(pd.DataFrame(pkts))
 
 for i in range(len(tx_traces)):
-  tx_traces[i] = tx_traces[i].groupby('sn').first()
-  print(tx_traces[i]['ipaddr'][0])
+    tx_traces[i] = tx_traces[i].groupby("sn").first()
+    print(tx_traces[i]["ipaddr"][0])
 
-#%% Evaluate PNAT
+# %% Evaluate PNAT
 
-pnat = {} # empty PNAT lookup table
+pnat = {}  # empty PNAT lookup table
 
-rex = re.compile(r'([0-9\.]+):([0-9]+) -> ([0-9\.]+):([0-9]+)')
+rex = re.compile(r"([0-9\.]+):([0-9]+) -> ([0-9\.]+):([0-9]+)")
 
-with open(f'{base_results_dir}/{scenario_dir}/{scenario_name}.log', 'r') as f:
-  for l in f:
-    r = rex.search(l)
-    if r is None or r.lastindex != 4:
-      continue
+with open(f"{base_results_dir}/{scenario_dir}/{scenario_name}.log", "r") as f:
+    for l in f:
+        r = rex.search(l)
+        if r is None or r.lastindex != 4:
+            continue
 
-    int_ipaddr, int_port, ext_ipaddr, ext_port = r.groups()
-    pnat[f'{ext_ipaddr}:{ext_port}'] = f'{int_ipaddr}'
+        int_ipaddr, int_port, ext_ipaddr, ext_port = r.groups()
+        pnat[f"{ext_ipaddr}:{ext_port}"] = f"{int_ipaddr}"
 
 
-#%%
+# %%
 rx_traces = []
 
-rex = re.compile(r'r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+'
-                 r' (?P<lte_port>[0-9]+) > 1337.+ns3::SeqTsHeader'
-                 r' \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+"
+    r" (?P<lte_port>[0-9]+) > 1337.+ns3::SeqTsHeader"
+    r" \(\(seq=(?P<sn>[0-9]+).+"
+)
 pkts = {k: [] for k in pnat.values()}
 
-with open(f'{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}', 'r') as f:
-  for l in f:
-    r = rex.match(l)
-
-    if r is not None:
-      ## DEBUG
-      # print(r[0])
-      # print(r.groupdict())
-      # break
-      ##
-      g = r.groupdict()
-      try:
-        host_addr = pnat[f'7.0.0.{g["lte_host_id"]}:{g["lte_port"]}']
-      except:
-        print(r[0])
-        print(r.groupdict())
-        raise Exception()
-
-      pkt = {
-        'time': float(g['time']),
-        'sn': float(g['sn'])
-      }
-      pkts[host_addr].append(pkt)
+with open(f"{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}", "r") as f:
+    for l in f:
+        r = rex.match(l)
+
+        if r is not None:
+            ## DEBUG
+            # print(r[0])
+            # print(r.groupdict())
+            # break
+            ##
+            g = r.groupdict()
+            try:
+                host_addr = pnat[f'7.0.0.{g["lte_host_id"]}:{g["lte_port"]}']
+            except:
+                print(r[0])
+                print(r.groupdict())
+                raise Exception()
+
+            pkt = {"time": float(g["time"]), "sn": float(g["sn"])}
+            pkts[host_addr].append(pkt)
 
 for k in sorted(pkts.keys(), key=lambda k: socket.inet_aton(k)):
-  print(k)
-  rx_traces.append(pd.DataFrame(pkts[k]))
+    print(k)
+    rx_traces.append(pd.DataFrame(pkts[k]))
 
 # %%
 latency = {}
 
 for i in range(len(tx_traces)):
-  lat = pd.merge(tx_traces[i], rx_traces[i], on='sn')
-  latency[tx_traces[i]['ipaddr'][0]] = (lat['time_y'] - lat['time_x']) * 1e3 # to milliseconds
+    lat = pd.merge(tx_traces[i], rx_traces[i], on="sn")
+    latency[tx_traces[i]["ipaddr"][0]] = (
+        lat["time_y"] - lat["time_x"]
+    ) * 1e3  # to milliseconds
 
 # %% Export data
-lat2matlab = {
-  'ClusterID': [],
-  'IPAddr': [],
-  'latency': []
-}
+lat2matlab = {"ClusterID": [], "IPAddr": [], "latency": []}
 
 hostid = 1
 for k in latency.keys():
-  for v in latency[k]:
-    lat2matlab["ClusterID"].append(k.split('.')[1])
-    lat2matlab["IPAddr"].append(hostid)
-    lat2matlab["latency"].append(v)
-  hostid += 1
+    for v in latency[k]:
+        lat2matlab["ClusterID"].append(k.split(".")[1])
+        lat2matlab["IPAddr"].append(hostid)
+        lat2matlab["latency"].append(v)
+    hostid += 1
 
-pd.DataFrame(lat2matlab).to_csv('./s3-latency_wifi+lte.csv')
+pd.DataFrame(lat2matlab).to_csv("./s3-latency_wifi+lte.csv")
 
 # %%
-color_palette = ['rgb(0,0,0)'
-                 for i in range(2, 9)]
-color_palette += ['rgb(0.5,0.5,0.5)'
-                  for i in range(2, 8)]
-color_palette += ['rgb(0.7,0.7,0.7)'
-                  for i in range(2, 9)]
-color_palette += ['rgb(0.7,0.7,0.7)'
-                  for i in range(2, 6)]
+color_palette = ["rgb(0,0,0)" for i in range(2, 9)]
+color_palette += ["rgb(0.5,0.5,0.5)" for i in range(2, 8)]
+color_palette += ["rgb(0.7,0.7,0.7)" for i in range(2, 9)]
+color_palette += ["rgb(0.7,0.7,0.7)" for i in range(2, 6)]
 
 fig = go.Figure()
-for k,v in latency.items():
-  fig.add_trace(go.Box(y=v, name=k))
-#fig = px.box(latency, labels=dict(value='Latency [ms]', variable='GU IP Address'))
-fig.show()
\ No newline at end of file
+for k, v in latency.items():
+    fig.add_trace(go.Box(y=v, name=k))
+# fig = px.box(latency, labels=dict(value='Latency [ms]', variable='GU IP Address'))
+fig.show()
diff --git a/analysis/lte-split_MacUlStats_per_drone.py b/analysis/lte-split_MacUlStats_per_drone.py
index 40e844c..58f3685 100755
--- a/analysis/lte-split_MacUlStats_per_drone.py
+++ b/analysis/lte-split_MacUlStats_per_drone.py
@@ -2,37 +2,39 @@
 import csv
 from argparse import ArgumentParser
 
-P = ArgumentParser(description='Parse LTE MAC Ul Stats file and output one CSV per drone containing LTE Cell ID and TB size')
-P.add_argument('results_dir', type=str, help='Results directory of reference')
+P = ArgumentParser(
+    description="Parse LTE MAC Ul Stats file and output one CSV per drone containing LTE Cell ID and TB size"
+)
+P.add_argument("results_dir", type=str, help="Results directory of reference")
 args = P.parse_args()
 
-COL_TIME   = 0
+COL_TIME = 0
 COL_CELLID = 1
-COL_IMSI   = 2
+COL_IMSI = 2
 COL_SIZETB = 7
-INPUT_FILE_NAME = 'lte-0-MacUlStats.txt'
-OUT_FILE_PREFIX = 'lte-UlMacStats-drone'
+INPUT_FILE_NAME = "lte-0-MacUlStats.txt"
+OUT_FILE_PREFIX = "lte-UlMacStats-drone"
 
 drones = []
 
-with open(f'{args.results_dir}/{INPUT_FILE_NAME}', 'r') as csvf:
-  csvr = csv.reader(csvf, delimiter='\t')
-  next(csvr) # discard header
+with open(f"{args.results_dir}/{INPUT_FILE_NAME}", "r") as csvf:
+    csvr = csv.reader(csvf, delimiter="\t")
+    next(csvr)  # discard header
 
-  for r in csvr:
-    time    = float(r[COL_TIME])
-    cellid  = int(r[COL_CELLID])
-    droneid = int(r[COL_IMSI]) - 1
-    sizetb  = int(r[COL_SIZETB])
+    for r in csvr:
+        time = float(r[COL_TIME])
+        cellid = int(r[COL_CELLID])
+        droneid = int(r[COL_IMSI]) - 1
+        sizetb = int(r[COL_SIZETB])
 
-    while len(drones) <= droneid:
-      drones.append([])
+        while len(drones) <= droneid:
+            drones.append([])
 
-    drones[droneid].append([time,cellid,sizetb])
+        drones[droneid].append([time, cellid, sizetb])
 
 for i_drone in range(len(drones)):
-  with open(f'{args.results_dir}/{OUT_FILE_PREFIX}_{i_drone}.csv', 'w') as csvf:
-    csvw = csv.writer(csvf)
+    with open(f"{args.results_dir}/{OUT_FILE_PREFIX}_{i_drone}.csv", "w") as csvf:
+        csvw = csv.writer(csvf)
 
-    csvw.writerow(['time', 'cellid', 'sizetb']) # heading
-    csvw.writerows(drones[i_drone])
+        csvw.writerow(["time", "cellid", "sizetb"])  # heading
+        csvw.writerows(drones[i_drone])
diff --git a/analysis/lte-split_RlcUlStats_per_drone.py b/analysis/lte-split_RlcUlStats_per_drone.py
index 13bb0f6..7e1ab38 100755
--- a/analysis/lte-split_RlcUlStats_per_drone.py
+++ b/analysis/lte-split_RlcUlStats_per_drone.py
@@ -2,42 +2,45 @@
 import csv
 from argparse import ArgumentParser
 
-P = ArgumentParser(description="Parse LTE Rlc Ul Stats file and output one file per drone/IMSI containing the LTE Cell ID")
-P.add_argument('rlc_filepath', type=str, help='LTE Rlc Ul Stats file path')
-P.add_argument('output_dir', type=str, help='Output directory where new CSV files will be stored')
+P = ArgumentParser(
+    description="Parse LTE Rlc Ul Stats file and output one file per drone/IMSI containing the LTE Cell ID"
+)
+P.add_argument("rlc_filepath", type=str, help="LTE Rlc Ul Stats file path")
+P.add_argument(
+    "output_dir", type=str, help="Output directory where new CSV files will be stored"
+)
 args = P.parse_args()
 
-COL_START  = 0
-COL_END    = 1
+COL_START = 0
+COL_END = 1
 COL_CELLID = 2
-COL_IMSI   = 3
-OUT_FILE_PREFIX = 'lte-rlc-drone'
+COL_IMSI = 3
+OUT_FILE_PREFIX = "lte-rlc-drone"
 
 samples = []
 
 # Read everything and agglomerate data in samples
-with open(args.rlc_filepath, 'r') as rlcf:
-  csvr = csv.reader(rlcf, delimiter='\t')
+with open(args.rlc_filepath, "r") as rlcf:
+    csvr = csv.reader(rlcf, delimiter="\t")
 
-  next(csvr) # Discard header
-  for row in csvr:
-    imsi = int(row[COL_IMSI])
-    while imsi > len(samples):
-      samples.append([])
+    next(csvr)  # Discard header
+    for row in csvr:
+        imsi = int(row[COL_IMSI])
+        while imsi > len(samples):
+            samples.append([])
 
-    start = float(row[COL_START])
-    end = float(row[COL_END])
-    cellId = int(row[COL_CELLID])
+        start = float(row[COL_START])
+        end = float(row[COL_END])
+        cellId = int(row[COL_CELLID])
 
-    samples[imsi - 1].append([start, end, cellId])
+        samples[imsi - 1].append([start, end, cellId])
 
 # for each imsi in samples, write csv
 i_drone = 0
 for d in samples:
-  with open(f'{args.output_dir}/{OUT_FILE_PREFIX}_{i_drone}.csv', 'w') as f:
-    csvw = csv.writer(f)
-    csvw.writerow(['start', 'end', 'cellId']) # header
-    csvw.writerows(d)
-
-  i_drone += 1
+    with open(f"{args.output_dir}/{OUT_FILE_PREFIX}_{i_drone}.csv", "w") as f:
+        csvw = csv.writer(f)
+        csvw.writerow(["start", "end", "cellId"])  # header
+        csvw.writerows(d)
 
+    i_drone += 1
diff --git a/analysis/lte-throughput_per_drone.py b/analysis/lte-throughput_per_drone.py
index 3e028b7..634d168 100755
--- a/analysis/lte-throughput_per_drone.py
+++ b/analysis/lte-throughput_per_drone.py
@@ -2,46 +2,54 @@
 import csv
 from argparse import ArgumentParser
 
-P = ArgumentParser(description='Parse LTE MAC Ul stats per drone to evaluate its throughput')
-P.add_argument('n_drones', type=int, help='Number of simulated drones')
-P.add_argument('results_dir', type=str, help='Results directory of reference')
-P.add_argument('--use_Mbps', action='store_true', default=False, help='Report throughput in Mbps. Default: kbps')
+P = ArgumentParser(
+    description="Parse LTE MAC Ul stats per drone to evaluate its throughput"
+)
+P.add_argument("n_drones", type=int, help="Number of simulated drones")
+P.add_argument("results_dir", type=str, help="Results directory of reference")
+P.add_argument(
+    "--use_Mbps",
+    action="store_true",
+    default=False,
+    help="Report throughput in Mbps. Default: kbps",
+)
 args = P.parse_args()
 
-INPUT_CSV_PREFIX  = 'lte-UlMacStats-drone'
-OUTPUT_CSV_PREFIX = 'lte-throughput-drone' 
+INPUT_CSV_PREFIX = "lte-UlMacStats-drone"
+OUTPUT_CSV_PREFIX = "lte-throughput-drone"
 
 drones = []
 
 for i_drone in range(args.n_drones):
-  drones.append([])
-  txbytes = 0
-  timeref = 0.0
+    drones.append([])
+    txbytes = 0
+    timeref = 0.0
 
-  with open(f'{args.results_dir}/{INPUT_CSV_PREFIX}_{i_drone}.csv') as csvf:
-    csvr = csv.reader(csvf)
-    next(csvr) # skip heading
+    with open(f"{args.results_dir}/{INPUT_CSV_PREFIX}_{i_drone}.csv") as csvf:
+        csvr = csv.reader(csvf)
+        next(csvr)  # skip heading
 
-    for r in csvr:
-      stime = float(r[0])
-      scellid = int(r[1])
-      ssizetb = int(r[2])
-      #drones[i_drone].append([time, cellid, sizetb])
+        for r in csvr:
+            stime = float(r[0])
+            scellid = int(r[1])
+            ssizetb = int(r[2])
+            # drones[i_drone].append([time, cellid, sizetb])
 
-      if int(stime) > timeref:
-        exp = 2 if args.use_Mbps else 1 # wether to use kbps or Mbps
-        drones[i_drone].append([int(timeref), scellid, txbytes * 8.0 / (1024.0 ** exp)])
-        timeref = stime
-        txbytes = 0.0
+            if int(stime) > timeref:
+                exp = 2 if args.use_Mbps else 1  # wether to use kbps or Mbps
+                drones[i_drone].append(
+                    [int(timeref), scellid, txbytes * 8.0 / (1024.0**exp)]
+                )
+                timeref = stime
+                txbytes = 0.0
 
-      txbytes += ssizetb
+            txbytes += ssizetb
 
 
 for i_drone in range(len(drones)):
-  with open(f'{args.results_dir}/{OUTPUT_CSV_PREFIX}_{i_drone}.csv', 'w') as csvf:
-    csvw = csv.writer(csvf)
-
-    hdr_scale = 'Mbps' if args.use_Mbps else 'kbps'
-    csvw.writerow(['time', 'cellid', hdr_scale]) # header
-    csvw.writerows(drones[i_drone])
+    with open(f"{args.results_dir}/{OUTPUT_CSV_PREFIX}_{i_drone}.csv", "w") as csvf:
+        csvw = csv.writer(csvf)
 
+        hdr_scale = "Mbps" if args.use_Mbps else "kbps"
+        csvw.writerow(["time", "cellid", hdr_scale])  # header
+        csvw.writerows(drones[i_drone])
diff --git a/analysis/merge_trajectory_powerconsumption.py b/analysis/merge_trajectory_powerconsumption.py
index 02a3ffd..bd95be6 100755
--- a/analysis/merge_trajectory_powerconsumption.py
+++ b/analysis/merge_trajectory_powerconsumption.py
@@ -3,23 +3,27 @@
 from argparse import ArgumentParser
 from math import isclose
 
-P = ArgumentParser(description='Merge trajectory data with power consumption for a given drone.')
-P.add_argument('trajectory_csv_filepath', type=str, help='Trajectory CSV file.')
-P.add_argument('power_consumption_csv_filepath', type=str, help='Drone power consumption CSV file.')
-P.add_argument('output_filepath', type=str, help='Output CSV filepath.')
+P = ArgumentParser(
+    description="Merge trajectory data with power consumption for a given drone."
+)
+P.add_argument("trajectory_csv_filepath", type=str, help="Trajectory CSV file.")
+P.add_argument(
+    "power_consumption_csv_filepath", type=str, help="Drone power consumption CSV file."
+)
+P.add_argument("output_filepath", type=str, help="Output CSV filepath.")
 args = P.parse_args()
 
-trf = open(args.trajectory_csv_filepath, 'r')
+trf = open(args.trajectory_csv_filepath, "r")
 tr_csvr = csv.reader(trf)
-next(tr_csvr) # ignore header
+next(tr_csvr)  # ignore header
 
-pcf = open(args.power_consumption_csv_filepath, 'r')
+pcf = open(args.power_consumption_csv_filepath, "r")
 pc_csvr = csv.reader(pcf)
-next(pc_csvr) # ignore header
+next(pc_csvr)  # ignore header
 
-of = open(args.output_filepath, 'w')
-of_csvw = csv.writer(of, lineterminator='\n')
-of_csvw.writerow(['time', 'x', 'y', 'z', 'power', 'pstate'])
+of = open(args.output_filepath, "w")
+of_csvw = csv.writer(of, lineterminator="\n")
+of_csvw.writerow(["time", "x", "y", "z", "power", "pstate"])
 
 trr = next(tr_csvr)
 pcr = next(pc_csvr)
@@ -27,19 +31,19 @@
 pcr_time = float(pcr[0])
 
 try:
-  while trr and pcr:
-    if isclose(trr_time, pcr_time, abs_tol=0.05):
-      of_csvw.writerow([trr_time, trr[0], trr[1], trr[2], pcr[1], pcr[2]])
-      trr = next(tr_csvr)
-      trr_time = float(trr[3])
-    elif trr_time > pcr_time:
-      pcr = next(pc_csvr)
-      pcr_time = float(pcr[0])
-    elif pcr_time > trr_time:
-      trr = next(tr_csvr)
-      trr_time = float(trr[3])
+    while trr and pcr:
+        if isclose(trr_time, pcr_time, abs_tol=0.05):
+            of_csvw.writerow([trr_time, trr[0], trr[1], trr[2], pcr[1], pcr[2]])
+            trr = next(tr_csvr)
+            trr_time = float(trr[3])
+        elif trr_time > pcr_time:
+            pcr = next(pc_csvr)
+            pcr_time = float(pcr[0])
+        elif pcr_time > trr_time:
+            trr = next(tr_csvr)
+            trr_time = float(trr[3])
 except:
-  pass
+    pass
 
 of.close()
 pcf.close()
diff --git a/analysis/niro.py b/analysis/niro.py
index 7a01fff..e8155b1 100644
--- a/analysis/niro.py
+++ b/analysis/niro.py
@@ -1,75 +1,82 @@
 import xml.etree.ElementTree as ET
+
 import matplotlib
 import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d import Axes3D
 import numpy as np
+from mpl_toolkits.mplot3d import Axes3D
+
 
 def parse_args():
     """
     Process arguments passed from the shell at the start of the program.
     """
     import argparse
-    parser = argparse.ArgumentParser(description='Niro Analysis Tool')
 
-    parser.add_argument('summary_file',
-                        type=str,
-                        help='XML Summary File of the Scenario')
+    parser = argparse.ArgumentParser(description="Niro Analysis Tool")
+
+    parser.add_argument(
+        "summary_file", type=str, help="XML Summary File of the Scenario"
+    )
 
     return parser.parse_args()
 
+
 class Position:
     def __init__(self, xml_pos):
-        self.x = float(xml_pos.find('x').text)
-        self.y = float(xml_pos.find('y').text)
-        self.z = float(xml_pos.find('z').text)
+        self.x = float(xml_pos.find("x").text)
+        self.y = float(xml_pos.find("y").text)
+        self.z = float(xml_pos.find("z").text)
 
     def __repr__(self):
-        return '<Entity pos ({},{},{})>'.format(self.x, self.y, self.z)
+        return "<Entity pos ({},{},{})>".format(self.x, self.y, self.z)
 
 
 class PositionWithTime(Position):
     def __init__(self, xml_pos):
-        self.t = int(xml_pos.find('t').text)
+        self.t = int(xml_pos.find("t").text)
         super().__init__(xml_pos)
 
     def __repr__(self):
-        return '<Entity '\
-               'pos ({},{},{}) @ {}ns>'.format(self.x, self.y,
-                                               self.z, self.t)
+        return "<Entity " "pos ({},{},{}) @ {}ns>".format(
+            self.x, self.y, self.z, self.t
+        )
 
 
 def get_entity_trajectory(xml_node):
-    return [PositionWithTime(xml_pos)
-            for xml_ent in xml_node
-            for xml_pos in xml_ent.findall('./position')]
+    return [
+        PositionWithTime(xml_pos)
+        for xml_ent in xml_node
+        for xml_pos in xml_ent.findall("./position")
+    ]
 
 
 def parse_drone_trajectories(xml_drones):
-    return [get_entity_trajectory(drone.findall('./trajectory'))
-            for drone in xml_drones]
+    return [
+        get_entity_trajectory(drone.findall("./trajectory")) for drone in xml_drones
+    ]
 
 
 def generate_position_graph(root):
     # Parse ZSP positions
-    zsps_position = get_entity_trajectory(root.findall('./zsps/zsp'))
-    drone_trajectories = parse_drone_trajectories(root.findall('./drones/drone'))
+    zsps_position = get_entity_trajectory(root.findall("./zsps/zsp"))
+    drone_trajectories = parse_drone_trajectories(root.findall("./drones/drone"))
 
     # Generate space graph
     fig = plt.figure()
-    ax = fig.add_subplot(111, projection='3d')
-    ax.set_title('Drone Trajectories and ZSP positions')
-    ax.set_xlabel('[m]')
-    ax.set_ylabel('[m]')
-    ax.set_zlabel('[m]')
+    ax = fig.add_subplot(111, projection="3d")
+    ax.set_title("Drone Trajectories and ZSP positions")
+    ax.set_xlabel("[m]")
+    ax.set_ylabel("[m]")
+    ax.set_zlabel("[m]")
 
     # Plot ZSPs as a serie of "+"
     zsps_x = [zsp.x for zsp in zsps_position]
     zsps_y = [zsp.y for zsp in zsps_position]
     zsps_z = [zsp.z for zsp in zsps_position]
-    ax.scatter(zsps_x, zsps_y, zsps_z, marker='+', label='ZSP')
+    ax.scatter(zsps_x, zsps_y, zsps_z, marker="+", label="ZSP")
 
     # drone index
-    cmap = matplotlib.cm.get_cmap('Set1')
+    cmap = matplotlib.cm.get_cmap("Set1")
     i = 1
 
     # Plot drones trajectories as 3D lines
@@ -82,9 +89,9 @@ def generate_position_graph(root):
 
         color = cmap(i)
 
-        ax.scatter(dx[0], dy[0], dz[0], marker='.', c=color, label='Drone start')
-        ax.scatter(dx[-1], dy[-1], dz[-1], marker='x', c=color, label='Drone end')
-        ax.plot(dx, dy, dz, c=color, label='Drone trajectory')
+        ax.scatter(dx[0], dy[0], dz[0], marker=".", c=color, label="Drone start")
+        ax.scatter(dx[-1], dy[-1], dz[-1], marker="x", c=color, label="Drone end")
+        ax.plot(dx, dy, dz, c=color, label="Drone trajectory")
 
         i += 1
 
@@ -92,46 +99,51 @@ def generate_position_graph(root):
 
 
 def generate_rssi_graph(root):
-    drones_rssi = root.findall('./drones/drone/networkStacks/stack/phy/signal')
+    drones_rssi = root.findall("./drones/drone/networkStacks/stack/phy/signal")
 
     # Generate graph
     fig = plt.figure()
     ax = fig.add_subplot(111)
-    ax.set_title('RSSI over time')
-    ax.set_xlabel('Time [s]')
-    ax.set_ylabel('RSSI [dBm]')
+    ax.set_title("RSSI over time")
+    ax.set_xlabel("Time [s]")
+    ax.set_ylabel("RSSI [dBm]")
 
     for drone_rssi in drones_rssi:
         entries = []
         senders = []
 
-        for s in drone_rssi.findall('./rssi'):
-            sender = s.attrib['from']
+        for s in drone_rssi.findall("./rssi"):
+            sender = s.attrib["from"]
             if sender not in senders:
                 senders.append(sender)
 
-            entries.append({
-                'value': float(s.attrib['value']),
-                'time':  float(s.attrib['time']) * 0.000000001, # ns to s
-                'from':  s.attrib['from']
-            })
+            entries.append(
+                {
+                    "value": float(s.attrib["value"]),
+                    "time": float(s.attrib["time"]) * 0.000000001,  # ns to s
+                    "from": s.attrib["from"],
+                }
+            )
 
         # discriminate information fluxes by sender address
         for sender in senders:
-            flux = [e for e in entries if e['from'] == sender]
-            time = [e['time'] for e in flux]
-            rssi = [e['value'] for e in flux]
+            flux = [e for e in entries if e["from"] == sender]
+            time = [e["time"] for e in flux]
+            rssi = [e["value"] for e in flux]
 
             ax.plot(time, rssi)
 
 
 def welcome_the_user(root):
-    datetime = root.attrib['executedAt'].split('.')
+    datetime = root.attrib["executedAt"].split(".")
     date = datetime[0]
-    time = datetime[1].split('-')
+    time = datetime[1].split("-")
 
-    print('Analysing Scenario {} started in {} at {}:{}:{}'
-        .format(root.attrib['scenario'], date, time[0], time[1], time[2]))
+    print(
+        "Analysing Scenario {} started in {} at {}:{}:{}".format(
+            root.attrib["scenario"], date, time[0], time[1], time[2]
+        )
+    )
 
 
 def analyse(filepath):
@@ -154,4 +166,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/analysis/pcap-throughput_per_drone.py b/analysis/pcap-throughput_per_drone.py
index d3a8dd2..1c10a6e 100755
--- a/analysis/pcap-throughput_per_drone.py
+++ b/analysis/pcap-throughput_per_drone.py
@@ -2,43 +2,49 @@
 import csv
 from argparse import ArgumentParser
 
-P = ArgumentParser(description='Translate TCP traffic from CSV in throughput')
-P.add_argument('n_drones', type=int, help='Number of simulated drones')
-P.add_argument('results_path', type=str, help='Results directory of reference')
-P.add_argument('--use_Mbps', action='store_true', default=False, help='Report throughput in Mbps. Default: kbps')
+P = ArgumentParser(description="Translate TCP traffic from CSV in throughput")
+P.add_argument("n_drones", type=int, help="Number of simulated drones")
+P.add_argument("results_path", type=str, help="Results directory of reference")
+P.add_argument(
+    "--use_Mbps",
+    action="store_true",
+    default=False,
+    help="Report throughput in Mbps. Default: kbps",
+)
 args = P.parse_args()
 
-input_file_prefix = 'pcap_lte_tcp_len'
-output_file_prefix = 'pcap-throughput'
+input_file_prefix = "pcap_lte_tcp_len"
+output_file_prefix = "pcap-throughput"
 drones = []
 
 for i_drone in range(args.n_drones):
-  drones.append([])
-  txbytes = 0
-  timeref = 0.0
+    drones.append([])
+    txbytes = 0
+    timeref = 0.0
 
-  with open(f'{args.results_path}/{input_file_prefix}-drone_{i_drone}.csv') as csvf:
-    csvr = csv.reader(csvf)
-    next(csvr) # skip heading
+    with open(f"{args.results_path}/{input_file_prefix}-drone_{i_drone}.csv") as csvf:
+        csvr = csv.reader(csvf)
+        next(csvr)  # skip heading
 
-    for r in csvr:
-      stime = float(r[0])
-      spayload = int(r[1])
+        for r in csvr:
+            stime = float(r[0])
+            spayload = int(r[1])
 
-      if int(stime) > timeref:
-        exp = 2 if args.use_Mbps else 1
-        drones[i_drone].append([int(timeref), txbytes * 8.0 / (1024.0 ** exp)])
-        timeref = stime
-        txbytes = 0.0
+            if int(stime) > timeref:
+                exp = 2 if args.use_Mbps else 1
+                drones[i_drone].append([int(timeref), txbytes * 8.0 / (1024.0**exp)])
+                timeref = stime
+                txbytes = 0.0
 
-      txbytes += spayload
+            txbytes += spayload
 
 
 for i_drone in range(len(drones)):
-    with open(f'{args.results_path}/{output_file_prefix}-drone_{i_drone}.csv', 'w') as csvf:
+    with open(
+        f"{args.results_path}/{output_file_prefix}-drone_{i_drone}.csv", "w"
+    ) as csvf:
         csvw = csv.writer(csvf)
 
-        hdr_scale = 'Mbps' if args.use_Mbps else 'kbps'
-        csvw.writerow(['time', hdr_scale]) # header
+        hdr_scale = "Mbps" if args.use_Mbps else "kbps"
+        csvw.writerow(["time", hdr_scale])  # header
         csvw.writerows(drones[i_drone])
-
diff --git a/analysis/plr.py b/analysis/plr.py
index 15466d6..443fb8e 100644
--- a/analysis/plr.py
+++ b/analysis/plr.py
@@ -1,7 +1,9 @@
 """
 Calculate and plot the PLR of given simulation results.
 """
+
 import xml.etree.ElementTree as ET
+
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -14,11 +16,12 @@ def parse_args():
         A namespace with parsed arguments as its properties.
     """
     import argparse
-    parser = argparse.ArgumentParser(description='Calculate and plot the PLR '
-                                     'of given simulation results.')
 
-    parser.add_argument('summary_file', type=str,
-                        help='IoD Sim Scenario Report.')
+    parser = argparse.ArgumentParser(
+        description="Calculate and plot the PLR " "of given simulation results."
+    )
+
+    parser.add_argument("summary_file", type=str, help="IoD Sim Scenario Report.")
 
     return parser.parse_args()
 
@@ -30,15 +33,20 @@ def welcome_the_user(root):
     Args:
         root: Decoded XML DOM root
     """
-    datetime = root.attrib['executedAt'].split('.')
+    datetime = root.attrib["executedAt"].split(".")
     date = datetime[0]
-    time = datetime[1].split('-')
+    time = datetime[1].split("-")
 
-    print('Analysing Scenario {} started in {} at {}:{}:{}'
-        .format(root.attrib['scenario'], date, time[0], time[1], time[2]))
+    print(
+        "Analysing Scenario {} started in {} at {}:{}:{}".format(
+            root.attrib["scenario"], date, time[0], time[1], time[2]
+        )
+    )
 
 
-def organize_data(root, entity_path, data_container_name, source_address, multi_stack=False):
+def organize_data(
+    root, entity_path, data_container_name, source_address, multi_stack=False
+):
     """
     Generic data collection function useful for organize_rx_data and
     organize_tx_data.
@@ -58,18 +66,18 @@ def organize_data(root, entity_path, data_container_name, source_address, multi_
         organized by the IP address of the entity and each IP address that had
         communication with.
     """
-    ms_path = 'networkStacks/' if multi_stack else ''
-    addr = 'sourceAddress' if source_address else 'destinationAddress'
+    ms_path = "networkStacks/" if multi_stack else ""
+    addr = "sourceAddress" if source_address else "destinationAddress"
     entities = root.findall(entity_path)
 
     entities_data = {}
     for e in entities:
         e_data = {}
-        ipv4 = e.find(f'./{ms_path}stack/ipv4/address').text
+        ipv4 = e.find(f"./{ms_path}stack/ipv4/address").text
         packets = e.findall(data_container_name)
 
         for pkt in packets:
-            sara = pkt.find(f'./{addr}').text
+            sara = pkt.find(f"./{addr}").text
 
             if sara not in e_data:
                 e_data[sara] = 0
@@ -94,8 +102,8 @@ def organize_rx_data(root):
         Multidimensional dictionary with all data received from each entity,
         organized by Sender IP address.
     """
-    zsps = organize_data(root, './zsps/zsp', './dataRx/transfer', True)
-    drones = organize_data(root, './drones/drone', './dataRx/transfer', True, True)
+    zsps = organize_data(root, "./zsps/zsp", "./dataRx/transfer", True)
+    drones = organize_data(root, "./drones/drone", "./dataRx/transfer", True, True)
 
     zsps.update(drones)  # merge
     return zsps
@@ -113,8 +121,8 @@ def organize_tx_data(root):
         Multidimensional dictionary with all data transmitted from each entity,
         organized by Target IP Address.
     """
-    zsps = organize_data(root, './zsps/zsp', './dataTx/transfer', False)
-    drones = organize_data(root, './drones/drone', './dataTx/transfer', False, True)
+    zsps = organize_data(root, "./zsps/zsp", "./dataTx/transfer", False)
+    drones = organize_data(root, "./drones/drone", "./dataTx/transfer", False, True)
 
     zsps.update(drones)  # merge
     return zsps
@@ -140,31 +148,28 @@ def analyse(filepath):
             pkts_tx = tx[sender][entity]
             pdr = float(pkts_rx) * 100.0 / float(pkts_tx)
 
-            stats.append({
-                'from': entity,
-                'to': sender,
-                'pdr': pdr,
-                'plr': 100.0 - pdr
-            })
+            stats.append({"from": entity, "to": sender, "pdr": pdr, "plr": 100.0 - pdr})
 
     # plot stats
     fig = plt.figure()
     ax = fig.add_subplot(111)
-    ax.set_title('PDR and PLR for each communication flux.')
-    ax.set_xlabel('Host')
-    ax.set_ylabel('[%]')
+    ax.set_title("PDR and PLR for each communication flux.")
+    ax.set_xlabel("Host")
+    ax.set_ylabel("[%]")
 
     width = 0.27  # width of the bars
     ind = np.arange(len(stats))  # x location of the groups
 
-    y = [x['pdr'] for x in stats]
-    ax.bar(ind, y, width, color='g')
+    y = [x["pdr"] for x in stats]
+    ax.bar(ind, y, width, color="g")
 
-    y = [x['plr'] for x in stats]
-    ax.bar(ind + width, y, width, color='r')
+    y = [x["plr"] for x in stats]
+    ax.bar(ind + width, y, width, color="r")
 
     ax.set_xticks(ind + width, minor=False)
-    ax.set_xticklabels([f"{i['from']} -> {i['to']}" for i in stats], fontdict=None, minor=False)
+    ax.set_xticklabels(
+        [f"{i['from']} -> {i['to']}" for i in stats], fontdict=None, minor=False
+    )
 
     plt.show()
 
@@ -177,5 +182,5 @@ def main():
     analyse(args.summary_file)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/analysis/plr2.py b/analysis/plr2.py
index f1007d5..3df1402 100644
--- a/analysis/plr2.py
+++ b/analysis/plr2.py
@@ -1,24 +1,32 @@
 """
 Plot PLR over distance of a drone from its ZSP.
 """
+
+import math
 import xml.etree.ElementTree as ET
+from collections import OrderedDict
+
 import numpy as np
 import plr
-from collections import OrderedDict
-import math
 from matplotlib import pyplot as plt
 
+
 def parse_args():
     import argparse
-    parser = argparse.ArgumentParser(description='Plot PDR/PLR data over '
-                                     'distance for different simulations with '
-                                     'different datarate.')
 
-    parser.add_argument('report_files', type=str, nargs='+',
-                        help='IoD Sim Scenario Reports.')
+    parser = argparse.ArgumentParser(
+        description="Plot PDR/PLR data over "
+        "distance for different simulations with "
+        "different datarate."
+    )
+
+    parser.add_argument(
+        "report_files", type=str, nargs="+", help="IoD Sim Scenario Reports."
+    )
 
     return parser.parse_args()
 
+
 def main():
     args = parse_args()
 
@@ -28,81 +36,67 @@ def main():
     root = xml.getroot()
 
     # what is the address of the ZSP?
-    zsp_addr = root.find('./zsps/zsp/stack/ipv4/address').text
+    zsp_addr = root.find("./zsps/zsp/stack/ipv4/address").text
 
     # what is the position of the ZSP?
-    xml_zsp_pos = root.find('./zsps/zsp/position')
+    xml_zsp_pos = root.find("./zsps/zsp/position")
     zsp_pos = {
-        'x': float(xml_zsp_pos.find('x').text),
-        'y': float(xml_zsp_pos.find('y').text),
-        'z': float(xml_zsp_pos.find('z').text)
+        "x": float(xml_zsp_pos.find("x").text),
+        "y": float(xml_zsp_pos.find("y").text),
+        "z": float(xml_zsp_pos.find("z").text),
     }
 
-    xml_drones = root.findall('./drones/drone')
+    xml_drones = root.findall("./drones/drone")
     drones = {}
     for xml_drone in xml_drones:
         # what drone is it?
-        drone_host = xml_drone.find('./networkStacks/stack/ipv4/address').text
+        drone_host = xml_drone.find("./networkStacks/stack/ipv4/address").text
 
         # what are the position assumed by the Drone (unique pos.)? At what time?
-        xml_pos = xml_drone.findall('./trajectory/position')
+        xml_pos = xml_drone.findall("./trajectory/position")
         pos = {}
         for xp in xml_pos:
-            x = float(xp.find('x').text)
-            y = float(xp.find('y').text)
-            z = float(xp.find('z').text)
-            t = int(xp.find('t').text)
+            x = float(xp.find("x").text)
+            y = float(xp.find("y").text)
+            z = float(xp.find("z").text)
+            t = int(xp.find("t").text)
 
-            pos[t] = {
-                'x': x,
-                'y': y,
-                'z': z
-            }
+            pos[t] = {"x": x, "y": y, "z": z}
 
         # what are the packets tx by the drone to the ZSP? At what time?
-        xml_pkts = xml_drone.findall('./dataTx/transfer')
+        xml_pkts = xml_drone.findall("./dataTx/transfer")
         tx = {}
         for xp in xml_pkts:
-            t = int(xp.find('./time').text)
-            src_addr = xp.find('./sourceAddress').text
-            dst_addr = xp.find('./destinationAddress').text
+            t = int(xp.find("./time").text)
+            src_addr = xp.find("./sourceAddress").text
+            dst_addr = xp.find("./destinationAddress").text
 
             if dst_addr != zsp_addr:
                 continue
 
-            tx[t] = {
-                'src': src_addr,
-                'dst': dst_addr
-            }
+            tx[t] = {"src": src_addr, "dst": dst_addr}
 
         # what are the packets rx by the ZSP from the drone? At what time?
-        xml_pkts = root.findall('./zsps/zsp/dataRx/transfer')
+        xml_pkts = root.findall("./zsps/zsp/dataRx/transfer")
         rx = {}
         for xp in xml_pkts:
-            t = int(xp.find('./time').text)
-            src_addr = xp.find('./sourceAddress').text
-            dst_addr = xp.find('./destinationAddress').text
+            t = int(xp.find("./time").text)
+            src_addr = xp.find("./sourceAddress").text
+            dst_addr = xp.find("./destinationAddress").text
 
             if src_addr != drone_host:
                 continue
 
-            rx[t] = {
-                'src': src_addr,
-                'dst': dst_addr
-            }
+            rx[t] = {"src": src_addr, "dst": dst_addr}
 
         # add new data to dictionary
-        drones[drone_host] = {
-            'pos': pos,
-            'tx': tx,
-            'rx': rx
-        }
+        drones[drone_host] = {"pos": pos, "tx": tx, "rx": rx}
 
     # data acquired.
 
     for host, drone in drones.items():
-        #plt.figure()
-        #plt.title(f'Drone {host}')
+        # plt.figure()
+        # plt.title(f'Drone {host}')
 
         x = []
         y = []
@@ -110,28 +104,27 @@ def main():
         tx = 1.0
         rx = 1.0
 
-        for post, posp in drone['pos'].items():
+        for post, posp in drone["pos"].items():
             dist = gd(posp, zsp_pos)
 
-            for pktt, _ in drone['tx'].items():
+            for pktt, _ in drone["tx"].items():
                 if pktt > post:
                     break
 
                 tx += 1.0
 
-            for pktt, _ in drone['rx'].items():
+            for pktt, _ in drone["rx"].items():
                 if pktt > post:
                     break
 
                 rx += 1.0
 
             x.append(dist)
-            #y.append(rx * 100.0 / tx)
+            # y.append(rx * 100.0 / tx)
             y.append(tx - rx)
 
         # NEED TO ORDER AND FILTER OUT DUPLICATES OF X AND Y, ELSE THEY CANNOT BE PLOTTED!
 
-
         plt.figure()
 
         x_uniq = np.unique(x)
@@ -141,18 +134,19 @@ def main():
             y_filt.append(np.mean(v))
 
         plt.plot(x_uniq, y_filt)
-        #plt.hist(y, log=True)
-        #plt.scatter(x, y)
+        # plt.hist(y, log=True)
+        # plt.scatter(x, y)
         plt.show()
 
+
 def gd(a, b):
     """
     Compute geometric distance between 3D points.
     """
-    return math.sqrt((a['x'] + b['x']) ** 2
-                     + (a['y'] + b['y']) ** 2
-                     + (a['z'] + b['z']) ** 2)
+    return math.sqrt(
+        (a["x"] + b["x"]) ** 2 + (a["y"] + b["y"]) ** 2 + (a["z"] + b["z"]) ** 2
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/analysis/plr_datarate.py b/analysis/plr_datarate.py
index 0d55059..9c97676 100644
--- a/analysis/plr_datarate.py
+++ b/analysis/plr_datarate.py
@@ -2,13 +2,16 @@
 Plot PDR/PLR data over distance for different simulations with
 different datarate.
 """
+
+import math
 import xml.etree.ElementTree as ET
+from collections import OrderedDict
+
 import numpy as np
 import plr
-from collections import OrderedDict
-import math
 from matplotlib import pyplot as plt
 
+
 def parse_args():
     """
     Parse program arguments, useful to behave like a full-fledged CLI program.
@@ -17,12 +20,16 @@ def parse_args():
         A namespace with parsed arguments as its properties.
     """
     import argparse
-    parser = argparse.ArgumentParser(description='Plot PDR/PLR data over '
-                                     'distance for different simulations with '
-                                     'different datarate.')
 
-    parser.add_argument('report_files', type=str, nargs='+',
-                        help='IoD Sim Scenario Reports.')
+    parser = argparse.ArgumentParser(
+        description="Plot PDR/PLR data over "
+        "distance for different simulations with "
+        "different datarate."
+    )
+
+    parser.add_argument(
+        "report_files", type=str, nargs="+", help="IoD Sim Scenario Reports."
+    )
 
     return parser.parse_args()
 
@@ -34,50 +41,57 @@ def welcome_the_user(root):
     Args:
         root: Decoded XML DOM root
     """
-    datetime = root.attrib['executedAt'].split('.')
+    datetime = root.attrib["executedAt"].split(".")
     date = datetime[0]
-    time = datetime[1].split('-')
+    time = datetime[1].split("-")
 
-    print('Analysing Scenario {} started in {} at {}:{}:{}'
-        .format(root.attrib['scenario'], date, time[0], time[1], time[2]))
+    print(
+        "Analysing Scenario {} started in {} at {}:{}:{}".format(
+            root.attrib["scenario"], date, time[0], time[1], time[2]
+        )
+    )
 
 
 def get_entity_trajectory(xml_node, entity_identifier, entity_type):
     ret = {}
 
-    for xml_pos in xml_node.findall('./position'):
-        t = xml_pos.find('t').text
+    for xml_pos in xml_node.findall("./position"):
+        t = xml_pos.find("t").text
         ret[int(t)] = {
-            'type': 'position',
-            'entity': entity_identifier,
-            'entity_type': entity_type,
-            'x': float(xml_pos.find('x').text),
-            'y': float(xml_pos.find('y').text),
-            'z': float(xml_pos.find('z').text),
-            't': int(t)
+            "type": "position",
+            "entity": entity_identifier,
+            "entity_type": entity_type,
+            "x": float(xml_pos.find("x").text),
+            "y": float(xml_pos.find("y").text),
+            "z": float(xml_pos.find("z").text),
+            "t": int(t),
         }
 
     return ret
 
+
 def parse_drone_trajectories(xml_drones):
     trajectories = {}
 
     for drone in xml_drones:
         trajectories.update(
             get_entity_trajectory(
-                drone.find('./trajectory'),
-                drone.find('./networkStacks/stack/ipv4/address').text,
-                'drone'))
+                drone.find("./trajectory"),
+                drone.find("./networkStacks/stack/ipv4/address").text,
+                "drone",
+            )
+        )
 
     return trajectories
 
+
 def parse_zsp_positions(xml_zsps):
     positions = {}
 
     for zsp in xml_zsps:
-        zsp_pos = get_entity_trajectory(zsp,
-                                        zsp.find('./stack/ipv4/address').text,
-                                        'zsp')
+        zsp_pos = get_entity_trajectory(
+            zsp, zsp.find("./stack/ipv4/address").text, "zsp"
+        )
 
         # to resolve conflicts at 0ns, continuely add 1ns, which is not a critical offset
         for k, v in zsp_pos.items():
@@ -88,6 +102,7 @@ def parse_zsp_positions(xml_zsps):
 
     return positions
 
+
 def get_entities_position(root):
     """
     Get the position of the entities simulated.
@@ -98,14 +113,21 @@ def get_entities_position(root):
     positions = {}
 
     # Update positions with the ZSP ones
-    positions.update(parse_zsp_positions(root.findall('./zsps/zsp')))
+    positions.update(parse_zsp_positions(root.findall("./zsps/zsp")))
     # then with drones
-    positions.update(parse_drone_trajectories(root.findall('./drones/drone')))
+    positions.update(parse_drone_trajectories(root.findall("./drones/drone")))
 
     return positions
 
 
-def organize_data(root, entity_path, data_container_name, is_rx=True, is_drone=False, multi_stack=False):
+def organize_data(
+    root,
+    entity_path,
+    data_container_name,
+    is_rx=True,
+    is_drone=False,
+    multi_stack=False,
+):
     """
     Generic data collection function useful for organize_rx_data and
     organize_tx_data.
@@ -125,30 +147,30 @@ def organize_data(root, entity_path, data_container_name, is_rx=True, is_drone=F
         organized by the IP address of the entity and each IP address that had
         communication with.
     """
-    ms_path = 'networkStacks/' if multi_stack else ''
+    ms_path = "networkStacks/" if multi_stack else ""
     entities = root.findall(entity_path)
 
     timeline = {}
     for e in entities:
         e_data = {}
-        host = e.find(f'./{ms_path}stack/ipv4/address').text
+        host = e.find(f"./{ms_path}stack/ipv4/address").text
         packets = e.findall(data_container_name)
 
         for pkt in packets:
-            time = int(pkt.find('./time').text)
+            time = int(pkt.find("./time").text)
 
             if time in e_data:
                 print("dup!")
 
             e_data[time] = {
                 # pick only what is needed
-                'type': 'packet',
-                'entity': host,
-                'entity_type': 'drone' if is_drone else 'zsp',
-                'packet_type': 'rx' if is_rx else 'tx',
-                'direction': pkt.find('./direction').text,
-                'src_addr': pkt.find('./sourceAddress').text,
-                'dest_addr': pkt.find('./destinationAddress').text
+                "type": "packet",
+                "entity": host,
+                "entity_type": "drone" if is_drone else "zsp",
+                "packet_type": "rx" if is_rx else "tx",
+                "direction": pkt.find("./direction").text,
+                "src_addr": pkt.find("./sourceAddress").text,
+                "dest_addr": pkt.find("./destinationAddress").text,
             }
 
         timeline.update(e_data)
@@ -170,8 +192,22 @@ def organize_rx_data(root):
     """
     rx_data = {}
 
-    zsps = organize_data(root, './zsps/zsp', './dataRx/transfer', is_rx=True, is_drone=False, multi_stack=False)
-    drones = organize_data(root, './drones/drone', './dataRx/transfer', is_rx=True, is_drone=True, multi_stack=True)
+    zsps = organize_data(
+        root,
+        "./zsps/zsp",
+        "./dataRx/transfer",
+        is_rx=True,
+        is_drone=False,
+        multi_stack=False,
+    )
+    drones = organize_data(
+        root,
+        "./drones/drone",
+        "./dataRx/transfer",
+        is_rx=True,
+        is_drone=True,
+        multi_stack=True,
+    )
 
     rx_data.update(zsps)
     rx_data.update(drones)
@@ -193,8 +229,22 @@ def organize_tx_data(root):
     """
     tx_data = {}
 
-    zsps = organize_data(root, './zsps/zsp', './dataTx/transfer', is_rx=False, is_drone=False, multi_stack=False)
-    drones = organize_data(root, './drones/drone', './dataTx/transfer', is_rx=False, is_drone=True, multi_stack=True)
+    zsps = organize_data(
+        root,
+        "./zsps/zsp",
+        "./dataTx/transfer",
+        is_rx=False,
+        is_drone=False,
+        multi_stack=False,
+    )
+    drones = organize_data(
+        root,
+        "./drones/drone",
+        "./dataTx/transfer",
+        is_rx=False,
+        is_drone=True,
+        multi_stack=True,
+    )
 
     tx_data.update(zsps)
     tx_data.update(drones)
@@ -206,9 +256,9 @@ def gd(a, b):
     """
     Compute geometric distance between 3D points.
     """
-    return math.sqrt((a['x'] + b['x']) ** 2
-                     + (a['y'] + b['y']) ** 2
-                     + (a['z'] + b['z']) ** 2)
+    return math.sqrt(
+        (a["x"] + b["x"]) ** 2 + (a["y"] + b["y"]) ** 2 + (a["z"] + b["z"]) ** 2
+    )
 
 
 def analyse(files):
@@ -238,45 +288,51 @@ def analyse(files):
     print("Events per scenario:", [len(t.keys()) for t in timelines])
 
     for t in timelines:
-        zsp_pos = [p
-                   for _,p in t.items()
-                   if p['type'] == 'position' and p['entity_type'] == 'zsp']
+        zsp_pos = [
+            p
+            for _, p in t.items()
+            if p["type"] == "position" and p["entity_type"] == "zsp"
+        ]
 
         pkt_dist_stat = {}
-        pkt_stat = {'rx': {}, 'tx': {}}
+        pkt_stat = {"rx": {}, "tx": {}}
 
         for _, event in t.items():
-            if event['type'] == 'position':
+            if event["type"] == "position":
                 # log distance with the closest ZSP
-                if event['entity'] not in pkt_dist_stat:
-                    pkt_dist_stat[event['entity']] = []
+                if event["entity"] not in pkt_dist_stat:
+                    pkt_dist_stat[event["entity"]] = []
 
                 # in case of key missing, we do not have enough data
                 try:
                     pdrs = []
-                    senders = pkt_stat['rx'][event['entity']]
+                    senders = pkt_stat["rx"][event["entity"]]
                     for sender, pkts_rx in senders.items():
-                        pkts_tx = pkt_stat['tx'][sender][event['entity']]
+                        pkts_tx = pkt_stat["tx"][sender][event["entity"]]
                         pdrs.append(float(pkts_rx) * 100.0 / float(pkts_tx))
 
-                    pkt_dist_stat[event['entity']].append(
-                        (min([gd(event, zp) for zp in zsp_pos]), pdrs))
+                    pkt_dist_stat[event["entity"]].append(
+                        (min([gd(event, zp) for zp in zsp_pos]), pdrs)
+                    )
                 except KeyError:
                     continue
-            elif event['type'] == 'packet':
-                if event['entity'] not in pkt_stat[event['packet_type']]:
-                    pkt_stat[event['packet_type']][event['entity']] = {}
+            elif event["type"] == "packet":
+                if event["entity"] not in pkt_stat[event["packet_type"]]:
+                    pkt_stat[event["packet_type"]][event["entity"]] = {}
 
                 # could be either tx or rx
-                addr_key = 'src_addr' if event['packet_type'] == 'rx' else 'dest_addr'
-                if event[addr_key] not in pkt_stat[event['packet_type']][event['entity']]:
-                    pkt_stat[event['packet_type']][event['entity']][event[addr_key]] = 0
+                addr_key = "src_addr" if event["packet_type"] == "rx" else "dest_addr"
+                if (
+                    event[addr_key]
+                    not in pkt_stat[event["packet_type"]][event["entity"]]
+                ):
+                    pkt_stat[event["packet_type"]][event["entity"]][event[addr_key]] = 0
 
-                pkt_stat[event['packet_type']][event['entity']][event[addr_key]] += 1
+                pkt_stat[event["packet_type"]][event["entity"]][event[addr_key]] += 1
 
         # we can now show them
         plt.figure()
-        plt.title('PDR of Drones over their distance from ZSP')
+        plt.title("PDR of Drones over their distance from ZSP")
 
         t_pkts = {}
         for host, data in pkt_dist_stat.items():
@@ -290,23 +346,19 @@ def analyse(files):
                 x.append(i[0])
                 y.append(i[1][0])
 
-            t_pkts[host] = {
-                'x': x,
-                'y': y
-            }
+            t_pkts[host] = {"x": x, "y": y}
 
-            print(len(t_pkts[host]['x']), len(set(t_pkts[host]['x'])))
+            print(len(t_pkts[host]["x"]), len(set(t_pkts[host]["x"])))
 
-            plt.plot(t_pkts[host]['x'], t_pkts[host]['y'])
-            plt.xlabel('Distance from ZSP [m]')
-            plt.ylabel('PDR [%]')
+            plt.plot(t_pkts[host]["x"], t_pkts[host]["y"])
+            plt.xlabel("Distance from ZSP [m]")
+            plt.ylabel("PDR [%]")
 
         print(len(pkt_dist_stat.items()))
 
         plt.show()
 
 
-
 def main():
     """
     Main control flow, called if this program is executed directly.
@@ -315,5 +367,5 @@ def main():
     analyse(args.report_files)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/analysis/plr_lte.py b/analysis/plr_lte.py
index 3a4475d..de5971c 100644
--- a/analysis/plr_lte.py
+++ b/analysis/plr_lte.py
@@ -1,105 +1,108 @@
 #!/usr/bin/env python
 
-#%%
+# %%
 import json
 import re
 
 import pandas as pd
 import plotly.express as px
 
-#%%
-base_results_dir = '../results/'
-scenario_name = 'paper_3-lte'
-scenario_datetime = '2022-03-15.16-53-33'
-scenario_dir = f'{scenario_name}-{scenario_datetime}'
-tx_trace_filename = 'paper_3-lte.log'
-internet_rx_trace_filename = 'internet-35-1.tr'
+# %%
+base_results_dir = "../results/"
+scenario_name = "paper_3-lte"
+scenario_datetime = "2022-03-15.16-53-33"
+scenario_dir = f"{scenario_name}-{scenario_datetime}"
+tx_trace_filename = "paper_3-lte.log"
+internet_rx_trace_filename = "internet-35-1.tr"
 
 lte_id2addr_offset = 2
 
-rex = re.compile(r'(?P<time>[0-9\.+]+)s (?P<nodeid>[0-9]+) .+ 200\.0\.0\.1 .+ '
-                 r'ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"(?P<time>[0-9\.+]+)s (?P<nodeid>[0-9]+) .+ 200\.0\.0\.1 .+ "
+    r"ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+"
+)
 
 tx_traces = {}
 pkts = []
 
-with open(f'{base_results_dir}/{scenario_dir}/{tx_trace_filename}', 'r') as f:
-  for l in f:
-    r = rex.match(l)
-    if r is not None:
-      ## DEBUG
-      # print(r[0])
-      # print(r.groupdict())
-      # break
-      ##
-      g = r.groupdict()
-      pkts.append({
-        'time': float(g['time']),
-        'nodeid': int(g['nodeid']),
-        'sn': int(g['sn'])
-      })
+with open(f"{base_results_dir}/{scenario_dir}/{tx_trace_filename}", "r") as f:
+    for l in f:
+        r = rex.match(l)
+        if r is not None:
+            ## DEBUG
+            # print(r[0])
+            # print(r.groupdict())
+            # break
+            ##
+            g = r.groupdict()
+            pkts.append(
+                {
+                    "time": float(g["time"]),
+                    "nodeid": int(g["nodeid"]),
+                    "sn": int(g["sn"]),
+                }
+            )
 
 for p in pkts:
-  lte_host_addr = f'7.0.0.{p["nodeid"] + lte_id2addr_offset}'
+    lte_host_addr = f'7.0.0.{p["nodeid"] + lte_id2addr_offset}'
 
-  if lte_host_addr in tx_traces:
-    tx_traces[lte_host_addr].append(p)
-  else:
-    tx_traces[lte_host_addr] = [p]
+    if lte_host_addr in tx_traces:
+        tx_traces[lte_host_addr].append(p)
+    else:
+        tx_traces[lte_host_addr] = [p]
 
 for k in tx_traces.keys():
-  tx_traces[k] = pd.DataFrame(tx_traces[k])
+    tx_traces[k] = pd.DataFrame(tx_traces[k])
 
 
-#%%
-ip_addrs = [f'7.0.0.{i}' for i in range(lte_id2addr_offset, len(tx_traces.keys()) + 1)]
+# %%
+ip_addrs = [f"7.0.0.{i}" for i in range(lte_id2addr_offset, len(tx_traces.keys()) + 1)]
 
-rex = re.compile(r'r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+'
-                 r' > 1337.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+"
+    r" > 1337.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+"
+)
 rx_traces = {k: [] for k in tx_traces.keys()}
 
-with open(f'{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}', 'r') as f:
-  for l in f:
-    r = rex.match(l)
-    if r is not None:
-      ## DEBUG
-      # print(r[0])
-      # print(r.groupdict())
-      # break
-      ##
-      g = r.groupdict()
-      host_addr = f'7.0.0.{g["lte_host_id"]}'
-
-      rx_traces[host_addr].append({
-        'time': float(g['time']),
-        'sn': int(g['sn'])
-      })
-
-rx_traces = {k: pd.DataFrame(v, columns=['time', 'sn']) for k,v in rx_traces.items()}
+with open(f"{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}", "r") as f:
+    for l in f:
+        r = rex.match(l)
+        if r is not None:
+            ## DEBUG
+            # print(r[0])
+            # print(r.groupdict())
+            # break
+            ##
+            g = r.groupdict()
+            host_addr = f'7.0.0.{g["lte_host_id"]}'
+
+            rx_traces[host_addr].append({"time": float(g["time"]), "sn": int(g["sn"])})
+
+rx_traces = {k: pd.DataFrame(v, columns=["time", "sn"]) for k, v in rx_traces.items()}
+
 
 # %%
 def eval_plr(tx, rx):
-  if tx.empty:
-    return 0.0
-  elif rx.empty:
-    return 1.0
-  else:
-    return 1.0 - (rx.count()[0] / tx.count()[0])
+    if tx.empty:
+        return 0.0
+    elif rx.empty:
+        return 1.0
+    else:
+        return 1.0 - (rx.count()[0] / tx.count()[0])
+
 
 # ridimensiona tx_traces escludendo pacchetti trasmessi che sono ancora in
 # circolo per la rete al termine della simulazione
 def reduce(tx, rx):
-  return tx[tx['sn'] <= rx['sn'].iloc[-1]]
+    return tx[tx["sn"] <= rx["sn"].iloc[-1]]
+
 
-plr = {
-  k: eval_plr(tx_traces[k], rx_traces[k])
-  for k in tx_traces.keys()
-}
+plr = {k: eval_plr(tx_traces[k], rx_traces[k]) for k in tx_traces.keys()}
 
 # %%
 fig = px.bar(plr.values())
-fig.update_yaxes(range = [0,1])
+fig.update_yaxes(range=[0, 1])
 fig.show()
 
-#%% Export PDR to matlab
-print(json.dumps(plr))
\ No newline at end of file
+# %% Export PDR to matlab
+print(json.dumps(plr))
diff --git a/analysis/plr_lte2.py b/analysis/plr_lte2.py
index 16e1948..74d66f8 100644
--- a/analysis/plr_lte2.py
+++ b/analysis/plr_lte2.py
@@ -1,44 +1,46 @@
 # TODO: Replace with plt_lte.py when the following TODOs are finished.
-#%%
+# %%
 import re
 from pathlib import Path
 
 import pandas as pd
 import plotly.express as px
 
-#%%
-results_dirpath = '../results/'
-scenario_name = 'paper_3-lte'
-execution_datetime = '2022-03-03.20-38-18'
-scenario_dirpath = f'{results_dirpath}/{scenario_name}-{execution_datetime}'
+# %%
+results_dirpath = "../results/"
+scenario_name = "paper_3-lte"
+execution_datetime = "2022-03-03.20-38-18"
+scenario_dirpath = f"{results_dirpath}/{scenario_name}-{execution_datetime}"
 
-#%%
-remote_trace_filepath = list(Path(scenario_dirpath).glob('./internet-*.tr'))[0]
-rex = re.compile(r'^r.+ns3::Ipv4Header.+(?P<ipaddr>7\.0\.0\.[0-9]+) > '
-                 r'200\.0\.0\.1.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+) '
-                 r'time=.+')
+# %%
+remote_trace_filepath = list(Path(scenario_dirpath).glob("./internet-*.tr"))[0]
+rex = re.compile(
+    r"^r.+ns3::Ipv4Header.+(?P<ipaddr>7\.0\.0\.[0-9]+) > "
+    r"200\.0\.0\.1.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+) "
+    r"time=.+"
+)
 
 matches = None
 with remote_trace_filepath.open() as f:
-  matches = list(filter(None, map(lambda x: rex.match(x), f.readlines())))
+    matches = list(filter(None, map(lambda x: rex.match(x), f.readlines())))
 
-assert(matches is not None)
+assert matches is not None
 rx_traces = pd.DataFrame([m.groupdict() for m in matches])
 
-#%%
+# %%
 plr = {}
-for k,g in rx_traces.groupby('ipaddr'):
-  last_sn = int(g['sn'].iloc[-1])
-  nrows = g.shape[0]
-  loss = last_sn - nrows + 1
-  plr[k] = loss / last_sn
+for k, g in rx_traces.groupby("ipaddr"):
+    last_sn = int(g["sn"].iloc[-1])
+    nrows = g.shape[0]
+    loss = last_sn - nrows + 1
+    plr[k] = loss / last_sn
 
 #! BUG: Mancano gli host con PLR al 100%
 # TODO: Il dizionario deve essere ordinato
 # TODO: Se tutto è ok e i risultati risultano in linea con plt_lte.py,
 #   individua il più efficiente e sostituisci
 
-#%%
+# %%
 fig = px.bar(x=plr.keys(), y=plr.values(), log_y=True)
-fig.update_xaxes(type='category')
-fig.show()
\ No newline at end of file
+fig.update_xaxes(type="category")
+fig.show()
diff --git a/analysis/plr_wifi+lte.py b/analysis/plr_wifi+lte.py
index 5d6acab..85abd7e 100644
--- a/analysis/plr_wifi+lte.py
+++ b/analysis/plr_wifi+lte.py
@@ -1,5 +1,4 @@
-
-#%%
+# %%
 import json
 import re
 import socket
@@ -7,126 +6,127 @@
 import pandas as pd
 import plotly.express as px
 
-#%%
+
+# %%
 def custom_val_map(k, v):
-  if k == 'ipaddr':
-    return v
-  else:
-    return float(v)
-
-#%%
-base_results_dir = '../results/'
-scenario_name = 'paper_3-wifi'
-scenario_datetime = '2022-03-15.16-53-30'
-scenario_dir = f'{scenario_name}-{scenario_datetime}'
-
-wifi_tx_trace_filenames = [f'wifi-phy-0-drones-host-{i}-0.log'
-                           for i in range(4,10)]
-wifi_tx_trace_filenames += [f'wifi-phy-1-drones-host-{i}-0.log'
-                            for i in range(10, 20)]
-wifi_tx_trace_filenames += [f'wifi-phy-2-drones-host-{i}-0.log'
-                            for i in range(20, 30)]
-wifi_tx_trace_filenames += [f'wifi-phy-3-drones-host-{i}-0.log'
-                            for i in range(30, 38)]
-
-internet_rx_trace_filename = 'internet-39-1.tr'
-
-rex = re.compile(r't (?P<time>[0-9\.+]+).+HeMcs(?P<mcs>[0-9]+).+ (?P<ipaddr>[0-9\.]+) > 200\.0\.0\.1.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+')
+    if k == "ipaddr":
+        return v
+    else:
+        return float(v)
+
+
+# %%
+base_results_dir = "../results/"
+scenario_name = "paper_3-wifi"
+scenario_datetime = "2022-03-15.16-53-30"
+scenario_dir = f"{scenario_name}-{scenario_datetime}"
+
+wifi_tx_trace_filenames = [f"wifi-phy-0-drones-host-{i}-0.log" for i in range(4, 10)]
+wifi_tx_trace_filenames += [f"wifi-phy-1-drones-host-{i}-0.log" for i in range(10, 20)]
+wifi_tx_trace_filenames += [f"wifi-phy-2-drones-host-{i}-0.log" for i in range(20, 30)]
+wifi_tx_trace_filenames += [f"wifi-phy-3-drones-host-{i}-0.log" for i in range(30, 38)]
+
+internet_rx_trace_filename = "internet-39-1.tr"
+
+rex = re.compile(
+    r"t (?P<time>[0-9\.+]+).+HeMcs(?P<mcs>[0-9]+).+ (?P<ipaddr>[0-9\.]+) > 200\.0\.0\.1.+ns3::SeqTsHeader \(\(seq=(?P<sn>[0-9]+).+"
+)
 
 tx_traces = []
 
 for fn in wifi_tx_trace_filenames:
-  pkts = []
+    pkts = []
 
-  with open(f'{base_results_dir}/{scenario_dir}/{fn}', 'r') as f:
-    for l in f:
-      r = rex.match(l)
+    with open(f"{base_results_dir}/{scenario_dir}/{fn}", "r") as f:
+        for l in f:
+            r = rex.match(l)
 
-      if r is not None:
-        ## DEBUG
-        # print(r[0])
-        # print(r.groupdict())
-        # break
-        ##
-        pkts.append({k: custom_val_map(k, v) for k,v in r.groupdict().items()})
+            if r is not None:
+                ## DEBUG
+                # print(r[0])
+                # print(r.groupdict())
+                # break
+                ##
+                pkts.append({k: custom_val_map(k, v) for k, v in r.groupdict().items()})
 
-  tx_traces.append(pd.DataFrame(pkts))
+    tx_traces.append(pd.DataFrame(pkts))
 
 
 for i in range(len(tx_traces)):
-  tx_traces[i] = tx_traces[i].groupby('sn', as_index=False).first()
-  # print(tx_traces[i]['ipaddr'][0]) #DEBUG
+    tx_traces[i] = tx_traces[i].groupby("sn", as_index=False).first()
+    # print(tx_traces[i]['ipaddr'][0]) #DEBUG
 
-#%% Evaluate PNAT
+# %% Evaluate PNAT
 
-pnat = {} # empty PNAT lookup table
+pnat = {}  # empty PNAT lookup table
 
-rex = re.compile(r'([0-9\.]+):([0-9]+) -> ([0-9\.]+):([0-9]+)')
+rex = re.compile(r"([0-9\.]+):([0-9]+) -> ([0-9\.]+):([0-9]+)")
 
-with open(f'{base_results_dir}/{scenario_dir}/{scenario_name}.log', 'r') as f:
-  for l in f:
-    r = rex.search(l)
-    if r is None or r.lastindex != 4:
-      continue
+with open(f"{base_results_dir}/{scenario_dir}/{scenario_name}.log", "r") as f:
+    for l in f:
+        r = rex.search(l)
+        if r is None or r.lastindex != 4:
+            continue
 
-    int_ipaddr, int_port, ext_ipaddr, ext_port = r.groups()
-    pnat[f'{ext_ipaddr}:{ext_port}'] = f'{int_ipaddr}'
+        int_ipaddr, int_port, ext_ipaddr, ext_port = r.groups()
+        pnat[f"{ext_ipaddr}:{ext_port}"] = f"{int_ipaddr}"
 
 
 ##%
 rx_traces = []
 
-rex = re.compile(r'r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+'
-                 r' (?P<lte_port>[0-9]+) > 1337.+ns3::SeqTsHeader'
-                 r' \(\(seq=(?P<sn>[0-9]+).+')
+rex = re.compile(
+    r"r (?P<time>[0-9\.+]+).+7\.0\.0\.(?P<lte_host_id>[0-9]+).+"
+    r" (?P<lte_port>[0-9]+) > 1337.+ns3::SeqTsHeader"
+    r" \(\(seq=(?P<sn>[0-9]+).+"
+)
 pkts = {k: [] for k in pnat.values()}
 
-with open(f'{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}', 'r') as f:
-  for l in f:
-    r = rex.match(l)
-
-    if r is not None:
-      ## DEBUG
-      # print(r[0])
-      # print(r.groupdict())
-      # break
-      ##
-      g = r.groupdict()
-      try:
-        host_addr = pnat[f'7.0.0.{g["lte_host_id"]}:{g["lte_port"]}']
-      except:
-        print(r[0])
-        print(r.groupdict())
-        raise Exception()
-
-      pkt = {
-        'time': float(g['time']),
-        'sn': float(g['sn'])
-      }
-      pkts[host_addr].append(pkt)
+with open(f"{base_results_dir}/{scenario_dir}/{internet_rx_trace_filename}", "r") as f:
+    for l in f:
+        r = rex.match(l)
+
+        if r is not None:
+            ## DEBUG
+            # print(r[0])
+            # print(r.groupdict())
+            # break
+            ##
+            g = r.groupdict()
+            try:
+                host_addr = pnat[f'7.0.0.{g["lte_host_id"]}:{g["lte_port"]}']
+            except:
+                print(r[0])
+                print(r.groupdict())
+                raise Exception()
+
+            pkt = {"time": float(g["time"]), "sn": float(g["sn"])}
+            pkts[host_addr].append(pkt)
 
 for k in sorted(pkts.keys(), key=lambda k: socket.inet_aton(k)):
-  # print(k) #DEBUG
-  rx_traces.append(pd.DataFrame(pkts[k]))
+    # print(k) #DEBUG
+    rx_traces.append(pd.DataFrame(pkts[k]))
+
 
 # %%
 def eval_plr(tx, rx):
-  if tx.empty:
-    return 0.0
-  elif rx.empty:
-    return 1.0
-  else:
-    return 1.0 - (rx.count()[0] / tx.count()[0])
+    if tx.empty:
+        return 0.0
+    elif rx.empty:
+        return 1.0
+    else:
+        return 1.0 - (rx.count()[0] / tx.count()[0])
+
 
 plr = {
-  tx_traces[i]['ipaddr'][0]: eval_plr(tx_traces[i], rx_traces[i])
-  for i in range(len(tx_traces))
+    tx_traces[i]["ipaddr"][0]: eval_plr(tx_traces[i], rx_traces[i])
+    for i in range(len(tx_traces))
 }
 
 # %%
 fig = px.bar(plr.values())
-fig.update_yaxes(range = [0,1])
+fig.update_yaxes(range=[0, 1])
 fig.show()
 
-#%% export PLR to matlab
+# %% export PLR to matlab
 print(json.dumps(plr))
diff --git a/analysis/preview.py b/analysis/preview.py
index 736dc45..bfab668 100644
--- a/analysis/preview.py
+++ b/analysis/preview.py
@@ -2,10 +2,11 @@
 A preview of a given simulation configuration in terms of drone trajectories and
 ZSPs position.
 """
+
 import jstyleson
-import numpy as np
 import matplotlib
 import matplotlib.pyplot as plt
+import numpy as np
 from mpl_toolkits.mplot3d import Axes3D
 from scipy.special import binom
 
@@ -14,7 +15,8 @@ class Point:
     """
     A high-level construct to manipulate and debug 3D points easily.
     """
-    def __init__(self, arr=[0,0,0], interest_level=0):
+
+    def __init__(self, arr=[0, 0, 0], interest_level=0):
         """
         Default constructor.
 
@@ -35,7 +37,7 @@ def __repr__(self):
             A construct that summarizes the properties in space of this
             Point instance.
         """
-        return f'Point(x:{self.x}; y:{self.y}; z:{self.z}; int:{self.interest})'
+        return f"Point(x:{self.x}; y:{self.y}; z:{self.z}; int:{self.interest})"
 
 
 def parse_args():
@@ -46,14 +48,19 @@ def parse_args():
         A namespace with parsed arguments as its properties.
     """
     import argparse
-    parser = argparse.ArgumentParser(description='Preview a given simulation '
-                                     'in terms of drone trajectories and ZSPs '
-                                     'position.')
-    parser.add_argument('--pdf', help='Plot the figure in a pdf file'
-                        '(default: display the plot on a GUI)', action="store_true")
 
-    parser.add_argument('input_file', type=str,
-                        help='IoD Sim Scenario Configuration.')
+    parser = argparse.ArgumentParser(
+        description="Preview a given simulation "
+        "in terms of drone trajectories and ZSPs "
+        "position."
+    )
+    parser.add_argument(
+        "--pdf",
+        help="Plot the figure in a pdf file" "(default: display the plot on a GUI)",
+        action="store_true",
+    )
+
+    parser.add_argument("input_file", type=str, help="IoD Sim Scenario Configuration.")
 
     return parser.parse_args()
 
@@ -68,7 +75,7 @@ def get_configuration(filepath):
     Returns:
         A dictionary containing decoded JSON data.
     """
-    with open(filepath, 'r') as f:
+    with open(filepath, "r") as f:
         jdoc = jstyleson.loads(f.read())
 
     return jdoc
@@ -86,36 +93,36 @@ def parse_positions(jd):
         Three arrays containing ZSP positions, Drones positions and Drone trajectories curve step.
     """
     # ZSPs are the easiest
-    zsps = jd['ZSPs']
+    zsps = jd["ZSPs"]
     zsp_positions = []
 
     for zsp in zsps:
-        mobilityModel=zsp['mobilityModel']['attributes']
-        if len(mobilityModel) > 0 :
+        mobilityModel = zsp["mobilityModel"]["attributes"]
+        if len(mobilityModel) > 0:
             for attributes in mobilityModel:
-                if attributes['name'] == 'Position':
-                    zsp_positions.append(Point(attributes['value']))
+                if attributes["name"] == "Position":
+                    zsp_positions.append(Point(attributes["value"]))
         else:
-            #support for not defined ZSPs Position
+            # support for not defined ZSPs Position
             zsp_positions.append(Point([0.0, 0.0, 0.0]))
 
     # get drones positions
-    drones = jd['drones']
+    drones = jd["drones"]
 
     drones_trajectories = []
     drones_curvestep = []
     flag = 0
     for drone in drones:
-        mobilityModel=drone['mobilityModel']['attributes']
+        mobilityModel = drone["mobilityModel"]["attributes"]
         trajectory = []
         for attributes in mobilityModel:
-            if attributes['name'] == 'FlightPlan':
-                for point in attributes['value']:
-                    trajectory.append(Point(point['position'], point['interest']))
+            if attributes["name"] == "FlightPlan":
+                for point in attributes["value"]:
+                    trajectory.append(Point(point["position"], point["interest"]))
                 drones_trajectories.append(trajectory)
-            if attributes['name'] == 'CurveStep':
+            if attributes["name"] == "CurveStep":
                 flag = 1
-                drones_curvestep.append(attributes['value'])
+                drones_curvestep.append(attributes["value"])
         # Support for not defined CurveStep
         if flag != 1:
             drones_curvestep.append(0.01)
@@ -135,7 +142,7 @@ def build_zsp_space(ax, zsps):
     zsps_x = [zsp.x for zsp in zsps]
     zsps_y = [zsp.y for zsp in zsps]
     zsps_z = [zsp.z for zsp in zsps]
-    ax.scatter(zsps_x, zsps_y, zsps_z, marker='+', label='ZSP')
+    ax.scatter(zsps_x, zsps_y, zsps_z, marker="+", label="ZSP")
 
 
 def build_drone_trajectory(drone_positions, step=0.01):
@@ -178,7 +185,7 @@ def build_drone_trajectory(drone_positions, step=0.01):
 
             for i in range(n):
                 a = binom(n, i)
-                b = (1 - t)**(n - i)
+                b = (1 - t) ** (n - i)
                 c = t**i
 
                 sum_x += a * b * c * tr[i].x
@@ -199,7 +206,7 @@ def build_drone_space(ax, drones):
         drones: Drone positions.
     """
     # drone index
-    cmap = matplotlib.cm.get_cmap('Set1')
+    cmap = matplotlib.cm.get_cmap("Set1")
     i = 1
 
     # Plot drones trajectories as 3D lines
@@ -212,12 +219,13 @@ def build_drone_space(ax, drones):
 
         color = cmap(i)
 
-        ax.scatter(dx[0], dy[0], dz[0], marker='.', c=color, label='Drone start')
-        ax.scatter(dx[-1], dy[-1], dz[-1], marker='x', c=color, label='Drone end')
-        ax.plot(dx, dy, dz, c=color, label='Drone trajectory')
+        ax.scatter(dx[0], dy[0], dz[0], marker=".", c=color, label="Drone start")
+        ax.scatter(dx[-1], dy[-1], dz[-1], marker="x", c=color, label="Drone end")
+        ax.plot(dx, dy, dz, c=color, label="Drone trajectory")
 
         i += 1
 
+
 def setup_3dplot():
     """
     Initialize 3D space plot.
@@ -226,14 +234,15 @@ def setup_3dplot():
         Matplotlib axes.
     """
     fig = plt.figure()
-    ax = fig.add_subplot(111, projection='3d')
-    ax.set_title('Drone Trajectories and ZSP positions')
-    ax.set_xlabel('[m]')
-    ax.set_ylabel('[m]')
-    ax.set_zlabel('[m]')
+    ax = fig.add_subplot(111, projection="3d")
+    ax.set_title("Drone Trajectories and ZSP positions")
+    ax.set_xlabel("[m]")
+    ax.set_ylabel("[m]")
+    ax.set_zlabel("[m]")
 
     return ax
 
+
 def main():
     """
     Program entry point if called directly.
@@ -253,11 +262,12 @@ def main():
 
     ax.legend()
     if args.pdf:
-        #For environment without graphic interface (Output is a .pdf file):
-        plt.savefig(args.input_file.replace('.json','.pdf'))
+        # For environment without graphic interface (Output is a .pdf file):
+        plt.savefig(args.input_file.replace(".json", ".pdf"))
     else:
-        #For environment with graphic interface:
+        # For environment with graphic interface:
         plt.show()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/analysis/progress.py b/analysis/progress.py
index 8a221c4..33b5709 100644
--- a/analysis/progress.py
+++ b/analysis/progress.py
@@ -1,52 +1,45 @@
-#%%
+# %%
 import re
 from pathlib import Path
 
 import pandas as pd
 import plotly.graph_objects as go
 
-#%%
-results_dirpath = '../results'
-scenario_dirname = 'progresses'
-scenario_dirpath = f'{results_dirpath}/{scenario_dirname}'
+# %%
+results_dirpath = "../results"
+scenario_dirname = "progresses"
+scenario_dirpath = f"{results_dirpath}/{scenario_dirname}"
 
-#%%
-filenames = sorted(Path(scenario_dirpath).glob('./*.log'))
-rex = re.compile(r'.*\( +(?P<speedup>[0-9\.]+)x real time\) (?P<events>[0-9]+) events processed')
+# %%
+filenames = sorted(Path(scenario_dirpath).glob("./*.log"))
+rex = re.compile(
+    r".*\( +(?P<speedup>[0-9\.]+)x real time\) (?P<events>[0-9]+) events processed"
+)
 
 samples = [
-  [
-    m.groupdict()
-    for m in filter(None, map(rex.match, f.open(mode='r').readlines()))
-  ]
-  for f in filenames
+    [m.groupdict() for m in filter(None, map(rex.match, f.open(mode="r").readlines()))]
+    for f in filenames
 ]
 
 performances = [pd.DataFrame(x) for x in samples]
 
-#%%
+# %%
 #!BUG: asse Y non ordinato!
-fig = go.Figure(data=[
-  go.Box(y=p['speedup'])
-  for p in performances
-])
+fig = go.Figure(data=[go.Box(y=p["speedup"]) for p in performances])
 fig.show()
 
-#%%
+# %%
 #!BUG: asse Y non ordinato!
-fig = go.Figure(data=[
-  go.Box(y=p['events'])
-  for p in performances
-])
+fig = go.Figure(data=[go.Box(y=p["events"]) for p in performances])
 fig.show()
 
-#%% Export to matlab
-p2mat = {'sid': [], 'speedup': [], 'events': []}
+# %% Export to matlab
+p2mat = {"sid": [], "speedup": [], "events": []}
 
 for i, p in enumerate(samples):
-  for s in p:
-    p2mat['sid'].append(i)
-    p2mat['speedup'].append(s['speedup'])
-    p2mat['events'].append(s['events'])
+    for s in p:
+        p2mat["sid"].append(i)
+        p2mat["speedup"].append(s["speedup"])
+        p2mat["events"].append(s["events"])
 
-pd.DataFrame(p2mat).to_csv('./perf.csv')
\ No newline at end of file
+pd.DataFrame(p2mat).to_csv("./perf.csv")
diff --git a/analysis/rem-2d-preview.py b/analysis/rem-2d-preview.py
index 6da6031..f75d5ba 100644
--- a/analysis/rem-2d-preview.py
+++ b/analysis/rem-2d-preview.py
@@ -1,48 +1,58 @@
-'''
-This scripts generates the plot of a Radio Environment Map using a .rem file.
-Simply pass the path to the .rem file as an argument and a .png file is generated
-in the same folder with same name and -plot as suffix.
-'''
-
-import matplotlib.pyplot as plt
-import matplotlib.cm as cm
-import numpy as np
-import sys
-
-assert len(sys.argv) > 1, "Not enough arguments passed"
-
-filepath = sys.argv[1]
-
-x,y,z,values = np.loadtxt(filepath).T
-
-#print(x, y, z)
-
-values = np.reshape(values, (len(set(x)), len(set(y)))).T
-values = np.flipud(values)
-
-#print(values)
-
-minimum = values.min()
-maximum = values.max()
-
-def normalize(x):
-  return np.zeros(x.shape) if (x.mean() == 0 and maximum - minimum == 0) \
-      else 100 * (10 * np.log10(x) - minimum) / (maximum - minimum)
-
-values = normalize(values)
-
-x_range = int(x.max()-x.min())
-y_range = int(y.max()-y.min())
-ratio_x = x_range / np.gcd(x_range, y_range)
-ratio_y = y_range / np.gcd(x_range, y_range)
-
-#print(ratio_x, ratio_y)
-#plt.rcParams["figure.figsize"] = [ratio_x,ratio_y]
-
-plt.imshow(values, extent=(x.min(), x.max(), y.min(), y.max()),
-           interpolation='nearest', cmap=cm.plasma)
-#plt.axis("tight")
-
-
-name = ".".join(filepath.split(".")[:-1])
+"""
+This scripts generates the plot of a Radio Environment Map using a .rem file.
+Simply pass the path to the .rem file as an argument and a .png file is generated
+in the same folder with same name and -plot as suffix.
+"""
+
+import sys
+
+import matplotlib.cm as cm
+import matplotlib.pyplot as plt
+import numpy as np
+
+assert len(sys.argv) > 1, "Not enough arguments passed"
+
+filepath = sys.argv[1]
+
+x, y, z, values = np.loadtxt(filepath).T
+
+# print(x, y, z)
+
+values = np.reshape(values, (len(set(x)), len(set(y)))).T
+values = np.flipud(values)
+
+# print(values)
+
+minimum = values.min()
+maximum = values.max()
+
+
+def normalize(x):
+    return (
+        np.zeros(x.shape)
+        if (x.mean() == 0 and maximum - minimum == 0)
+        else 100 * (10 * np.log10(x) - minimum) / (maximum - minimum)
+    )
+
+
+values = normalize(values)
+
+x_range = int(x.max() - x.min())
+y_range = int(y.max() - y.min())
+ratio_x = x_range / np.gcd(x_range, y_range)
+ratio_y = y_range / np.gcd(x_range, y_range)
+
+# print(ratio_x, ratio_y)
+# plt.rcParams["figure.figsize"] = [ratio_x,ratio_y]
+
+plt.imshow(
+    values,
+    extent=(x.min(), x.max(), y.min(), y.max()),
+    interpolation="nearest",
+    cmap=cm.plasma,
+)
+# plt.axis("tight")
+
+
+name = ".".join(filepath.split(".")[:-1])
 plt.savefig(name + "-preview")
diff --git a/analysis/rem-3d-preview.py b/analysis/rem-3d-preview.py
index 26b1282..20555e8 100644
--- a/analysis/rem-3d-preview.py
+++ b/analysis/rem-3d-preview.py
@@ -1,21 +1,22 @@
-from plyfile import PlyData, PlyElement
+import sys
+
 import matplotlib.pyplot as plt
 import numpy as np
-import sys
+from plyfile import PlyData, PlyElement
 
 assert len(sys.argv) > 1, "Not enough arguments passed"
-ply_file_path=sys.argv[1]
+ply_file_path = sys.argv[1]
 
 
 # Load the PLY file
 plydata = PlyData.read(ply_file_path)
 
 # Extract vertex data
-vertices = np.array(plydata['vertex'].data.tolist())
+vertices = np.array(plydata["vertex"].data.tolist())
 
-if (vertices.size == 0):
-  print("Operation aborted: no data found for this channel.", file=sys.stderr)
-  exit(1)
+if vertices.size == 0:
+    print("Operation aborted: no data found for this channel.", file=sys.stderr)
+    exit(1)
 
 # Extract point positions
 positions = vertices[:, 0:3]
@@ -25,16 +26,23 @@
 
 # Create a 3D plot
 fig = plt.figure()
-ax = fig.add_subplot(111, projection='3d')
+ax = fig.add_subplot(111, projection="3d")
 
 # Plot the point cloud with intensities
-ax.scatter(positions[:, 0], positions[:, 1], positions[:, 2], c=intensities/max(intensities), s=1, marker='o')
+ax.scatter(
+    positions[:, 0],
+    positions[:, 1],
+    positions[:, 2],
+    c=intensities / max(intensities),
+    s=1,
+    marker="o",
+)
 
 # Set the axis labels
-ax.set_xlabel('X')
-ax.set_ylabel('Y')
-ax.set_zlabel('Z')
+ax.set_xlabel("X")
+ax.set_ylabel("Y")
+ax.set_zlabel("Z")
 
 # Save the figure
 name = ".".join(ply_file_path.split(".")[:-1])
-plt.savefig(name + "-preview", dpi=300, bbox_inches='tight')
\ No newline at end of file
+plt.savefig(name + "-preview", dpi=300, bbox_inches="tight")
diff --git a/analysis/sinr_lte.py b/analysis/sinr_lte.py
index 25f9f21..94c6cec 100644
--- a/analysis/sinr_lte.py
+++ b/analysis/sinr_lte.py
@@ -1,25 +1,24 @@
-
-#%%
+# %%
 from pathlib import Path
 
 import numpy as np
 import pandas as pd
 
-#%%
-base_results_dir = '../results/'
+# %%
+base_results_dir = "../results/"
 # scenario_name = 'paper_3-lte'
 # scenario_dir = f'{scenario_name}-2022-03-03.20-38-18'
-scenario_name = 'paper_3-wifi'
-scenario_dir = f'{scenario_name}-2022-03-03.18-53-11'
-results_dir = f'{base_results_dir}/{scenario_dir}'
+scenario_name = "paper_3-wifi"
+scenario_dir = f"{scenario_name}-2022-03-03.18-53-11"
+results_dir = f"{base_results_dir}/{scenario_dir}"
 
-#%%
-sinr_trace_filepath = list(Path(results_dir).glob('./*-PhySinrUlStats.txt'))[0]
+# %%
+sinr_trace_filepath = list(Path(results_dir).glob("./*-PhySinrUlStats.txt"))[0]
 
-df = pd.read_csv(sinr_trace_filepath, sep='\t')
-df['sinr'] = 20 * np.log10(df['sinrLinear'])
+df = pd.read_csv(sinr_trace_filepath, sep="\t")
+df["sinr"] = 20 * np.log10(df["sinrLinear"])
 
-df.boxplot(column=['sinr'], by=['IMSI'])
+df.boxplot(column=["sinr"], by=["IMSI"])
 
 # %% Export to matlab
-df[['IMSI', 'sinr']].to_csv('./sinr-lte-relay.csv')
+df[["IMSI", "sinr"]].to_csv("./sinr-lte-relay.csv")
diff --git a/analysis/sinr_wifi.py b/analysis/sinr_wifi.py
index 6de477d..328ad5b 100644
--- a/analysis/sinr_wifi.py
+++ b/analysis/sinr_wifi.py
@@ -1,4 +1,4 @@
-#%%
+# %%
 # NOTE: Wi-Fi SNR reported in PCAP files are SINR. Refs:
 #   - https://www.nsnam.org/doxygen/interference-helper_8cc_source.html#l00362
 #   - https://www.nsnam.org/tutorials/consortium14/ns-3-training-session-5.pdf
@@ -7,15 +7,15 @@
 from pathlib import Path
 from statistics import mean
 
-import plotly.graph_objects as go
 import plotly.express as px
+import plotly.graph_objects as go
 
-#%%
-results_dirpath = '../results'
-scenario_name = 'paper_3-wifi'
-scenario_exec_datetime = '2022-03-03.18-53-11'
-scenario_dirname = f'{scenario_name}-{scenario_exec_datetime}'
-scenario_dirpath = f'{results_dirpath}/{scenario_dirname}'
+# %%
+results_dirpath = "../results"
+scenario_name = "paper_3-wifi"
+scenario_exec_datetime = "2022-03-03.18-53-11"
+scenario_dirname = f"{scenario_name}-{scenario_exec_datetime}"
+scenario_dirpath = f"{results_dirpath}/{scenario_dirname}"
 
 n_relays = 4
 # mac_stas = [
@@ -36,75 +36,63 @@
 #     for i in range(38, 46)
 #   ]
 # ]
-mac_stas = [
-  f'00:00:00:00:00:{i:02x}'
-  for i in range(10, 18)
-]
-mac_stas += [
-  f'00:00:00:00:00:{i:02x}'
-  for i in range(18, 28)
-]
-mac_stas += [
-  f'00:00:00:00:00:{i:02x}'
-  for i in range(28, 38)
-]
-mac_stas += [
-  f'00:00:00:00:00:{i:02x}'
-  for i in range(38, 46)
-]
+mac_stas = [f"00:00:00:00:00:{i:02x}" for i in range(10, 18)]
+mac_stas += [f"00:00:00:00:00:{i:02x}" for i in range(18, 28)]
+mac_stas += [f"00:00:00:00:00:{i:02x}" for i in range(28, 38)]
+mac_stas += [f"00:00:00:00:00:{i:02x}" for i in range(38, 46)]
 
 wlan_id_offsets = [4, 4, 4, 4]
 
-#%%
+
+# %%
 def safe_float(x):
-  try:
-    return float(x)
-  except ValueError:
-    return None
+    try:
+        return float(x)
+    except ValueError:
+        return None
+
 
 # Filter out relays by looking at wifi STAs PCAPs only
 def pcap_data(scenario_dirpath, phy_id, mac_stas, wlan_id_offset):
-  for pcap_path in Path(scenario_dirpath).glob(f'./wifi-phy-{phy_id}-*-0.pcap'):
-    wlan_host_id = int(pcap_path.name.split('-')[5]) - wlan_id_offset
-
-    # print(mac_stas, pcap_path, wlan_host_id)
-    # print(mac_stas[wlan_host_id])
-    args = [
-      'tshark',
-      '-r', pcap_path,
-      '-T', 'fields',
-      '-e', 'wlan_radio.snr',
-      f'wlan.addr == {mac_stas[wlan_host_id]} and wlan_radio.snr'
-    ]
+    for pcap_path in Path(scenario_dirpath).glob(f"./wifi-phy-{phy_id}-*-0.pcap"):
+        wlan_host_id = int(pcap_path.name.split("-")[5]) - wlan_id_offset
 
-    try:
-      resp = subprocess.run(args, check=True, capture_output=True)
-    except subprocess.CalledProcessError as e:
-      raise Exception(e.stderr)
+        # print(mac_stas, pcap_path, wlan_host_id)
+        # print(mac_stas[wlan_host_id])
+        args = [
+            "tshark",
+            "-r",
+            pcap_path,
+            "-T",
+            "fields",
+            "-e",
+            "wlan_radio.snr",
+            f"wlan.addr == {mac_stas[wlan_host_id]} and wlan_radio.snr",
+        ]
+
+        try:
+            resp = subprocess.run(args, check=True, capture_output=True)
+        except subprocess.CalledProcessError as e:
+            raise Exception(e.stderr)
 
-    snr_samples = list(map(safe_float, resp.stdout.decode('utf-8').split('\n')))
-    yield wlan_host_id, snr_samples
+        snr_samples = list(map(safe_float, resp.stdout.decode("utf-8").split("\n")))
+        yield wlan_host_id, snr_samples
 
-#%%
+
+# %%
 df = {
-  hid: snrs
-  for pi, wio in zip(range(n_relays), wlan_id_offsets)
-  for hid, snrs in pcap_data(scenario_dirpath, pi, mac_stas, wio)
+    hid: snrs
+    for pi, wio in zip(range(n_relays), wlan_id_offsets)
+    for hid, snrs in pcap_data(scenario_dirpath, pi, mac_stas, wio)
 }
 
-#%%
-means = [
-  mean(filter(None, v))
-  for v in df.values()
-]
-
-#%% Plot
-fig = go.Figure(data=[
-  go.Box(y=v)
-  for _,v in df.items()
-])
+# %%
+means = [mean(filter(None, v)) for v in df.values()]
+
+# %% Plot
+fig = go.Figure(data=[go.Box(y=v) for _, v in df.items()])
 fig.show()
 
-#%%
+# %%
 fig = px.bar(means)
 fig.show()
diff --git a/analysis/trajectory+cellid.py b/analysis/trajectory+cellid.py
index 92b6300..eb87eab 100755
--- a/analysis/trajectory+cellid.py
+++ b/analysis/trajectory+cellid.py
@@ -2,45 +2,46 @@
 import csv
 from argparse import ArgumentParser
 
-P = ArgumentParser(description='Combine LTE RLC data and trajectory in a single CSV per drone')
-P.add_argument('n_drones', type=int, help='Number of simulated drones')
-P.add_argument('results_dir', type=str, help='Results directory of reference')
+P = ArgumentParser(
+    description="Combine LTE RLC data and trajectory in a single CSV per drone"
+)
+P.add_argument("n_drones", type=int, help="Number of simulated drones")
+P.add_argument("results_dir", type=str, help="Results directory of reference")
 args = P.parse_args()
 
-INPUT_LTE_RLC_FILE_PREFIX = 'lte-rlc-drone'
-INPUT_TRAJECTORY_FILE_PREFIX = 'trajectory-drone'
-OUTPUT_FILE_PREFIX = 'traj+cellid-drone'
+INPUT_LTE_RLC_FILE_PREFIX = "lte-rlc-drone"
+INPUT_TRAJECTORY_FILE_PREFIX = "trajectory-drone"
+OUTPUT_FILE_PREFIX = "traj+cellid-drone"
 
 for i_drone in range(args.n_drones):
-  start = -1.0
-  cellid = 0
+    start = -1.0
+    cellid = 0
 
-  rlcf = open(f'{args.results_dir}/{INPUT_LTE_RLC_FILE_PREFIX}_{i_drone}.csv', 'r')
-  rlc_csvr = csv.reader(rlcf)
-  next(rlc_csvr) # discard header
+    rlcf = open(f"{args.results_dir}/{INPUT_LTE_RLC_FILE_PREFIX}_{i_drone}.csv", "r")
+    rlc_csvr = csv.reader(rlcf)
+    next(rlc_csvr)  # discard header
 
-  trf = open(f'{args.results_dir}/{INPUT_TRAJECTORY_FILE_PREFIX}_{i_drone}.csv', 'r')
-  trf_csvr = csv.reader(trf)
-  next(trf_csvr) # discard header
+    trf = open(f"{args.results_dir}/{INPUT_TRAJECTORY_FILE_PREFIX}_{i_drone}.csv", "r")
+    trf_csvr = csv.reader(trf)
+    next(trf_csvr)  # discard header
 
-  destf = open(f'{args.results_dir}/{OUTPUT_FILE_PREFIX}_{i_drone}.csv', 'w')
-  dest_csvw = csv.writer(destf)
-  dest_csvw.writerow(['x', 'y', 'z', 't', 'cellId'])
+    destf = open(f"{args.results_dir}/{OUTPUT_FILE_PREFIX}_{i_drone}.csv", "w")
+    dest_csvw = csv.writer(destf)
+    dest_csvw.writerow(["x", "y", "z", "t", "cellId"])
 
-  for r in trf_csvr:
-    x = float(r[0])
-    y = float(r[1])
-    z = float(r[2])
-    t = float(r[3])
+    for r in trf_csvr:
+        x = float(r[0])
+        y = float(r[1])
+        z = float(r[2])
+        t = float(r[3])
 
-    while t > start:
-      rlc_row = rlc_csvr.__next__()
-      start = float(rlc_row[0])
-      cellid = int(rlc_row[2])
+        while t > start:
+            rlc_row = rlc_csvr.__next__()
+            start = float(rlc_row[0])
+            cellid = int(rlc_row[2])
 
-    dest_csvw.writerow([x, y, z, t, cellid])
-
-  destf.close()
-  trf.close()
-  rlcf.close()
+        dest_csvw.writerow([x, y, z, t, cellid])
 
+    destf.close()
+    trf.close()
+    rlcf.close()
diff --git a/analysis/trajectory2csv.py b/analysis/trajectory2csv.py
index c466a94..b401f6d 100755
--- a/analysis/trajectory2csv.py
+++ b/analysis/trajectory2csv.py
@@ -3,41 +3,45 @@
 from argparse import ArgumentParser
 from xml.etree.ElementTree import ElementTree
 
-P = ArgumentParser(description='Parse drone trajectories from summary file')
-P.add_argument('summary_filepath', type=str, help='Summary file path')
-P.add_argument('results_dir', type=str, help='Destination directory where to store CSV files')
+P = ArgumentParser(description="Parse drone trajectories from summary file")
+P.add_argument("summary_filepath", type=str, help="Summary file path")
+P.add_argument(
+    "results_dir", type=str, help="Destination directory where to store CSV files"
+)
 args = P.parse_args()
 
-OUTPUT_FILE_PREFIX = 'trajectory-drone'
+OUTPUT_FILE_PREFIX = "trajectory-drone"
+
 
 def pick_float_from_el(parent, el_name):
-  v = parent.find(el_name)
-  assert(v is not None)
-  v = v.text
-  assert(v is not None)
-  return float(v)
+    v = parent.find(el_name)
+    assert v is not None
+    v = v.text
+    assert v is not None
+    return float(v)
+
 
 tree = ElementTree()
 tree.parse(args.summary_filepath)
 
 drones = tree.find("Drones")
-assert(drones is not None)
+assert drones is not None
 
 i_drone = 1
-for d in drones.iter('Drone'):
-  with open(f'{args.results_dir}/{OUTPUT_FILE_PREFIX}_{i_drone}.csv', 'w') as f:
-    csvw = csv.writer(f)
+for d in drones.iter("Drone"):
+    with open(f"{args.results_dir}/{OUTPUT_FILE_PREFIX}_{i_drone}.csv", "w") as f:
+        csvw = csv.writer(f)
 
-    csvw.writerow(['x','y','z','t']) # write headings
+        csvw.writerow(["x", "y", "z", "t"])  # write headings
 
-    trajectory = d.find('trajectory')
-    assert(trajectory is not None)
+        trajectory = d.find("trajectory")
+        assert trajectory is not None
 
-    for p in trajectory.iter('position'):
-      x = pick_float_from_el(p, 'x')
-      y = pick_float_from_el(p, 'y')
-      z = pick_float_from_el(p, 'z')
-      t = pick_float_from_el(p, 't') / 1e9
-      csvw.writerow([x,y,z,t])
+        for p in trajectory.iter("position"):
+            x = pick_float_from_el(p, "x")
+            y = pick_float_from_el(p, "y")
+            z = pick_float_from_el(p, "z")
+            t = pick_float_from_el(p, "t") / 1e9
+            csvw.writerow([x, y, z, t])
 
-  i_drone += 1
+    i_drone += 1
diff --git a/analysis/txt2ply.py b/analysis/txt2ply.py
index 6235663..0c220cd 100644
--- a/analysis/txt2ply.py
+++ b/analysis/txt2ply.py
@@ -1,11 +1,11 @@
-
 import sys
+
 assert len(sys.argv) > 1, "Not enough arguments passed"
-txt_file_path=sys.argv[1]
+txt_file_path = sys.argv[1]
 name = ".".join(txt_file_path.split(".")[:-1])
-ply_file_path= name+".ply"
+ply_file_path = name + ".ply"
 # Open the .txt file and read its contents
-with open(txt_file_path, 'r') as txt_file:
+with open(txt_file_path, "r") as txt_file:
     txt_contents = txt_file.read().splitlines()
 
 # Extract the vertices and faces from the .txt file
@@ -17,14 +17,16 @@
 
 
 # Write the vertices and faces to a new .ply file
-with open(ply_file_path, 'w') as ply_file:
-    ply_file.write('ply\n')
-    ply_file.write('format ascii 1.0\n')
-    ply_file.write('element vertex {}\n'.format(len(vertices)))
-    ply_file.write('property float x\n')
-    ply_file.write('property float y\n')
-    ply_file.write('property float z\n')
-    ply_file.write('property float intensity\n')
-    ply_file.write('end_header\n')
+with open(ply_file_path, "w") as ply_file:
+    ply_file.write("ply\n")
+    ply_file.write("format ascii 1.0\n")
+    ply_file.write("element vertex {}\n".format(len(vertices)))
+    ply_file.write("property float x\n")
+    ply_file.write("property float y\n")
+    ply_file.write("property float z\n")
+    ply_file.write("property float intensity\n")
+    ply_file.write("end_header\n")
     for vertex in vertices:
-        ply_file.write('{} {} {} {}\n'.format(vertex[0], vertex[1], vertex[2], vertex[3]))
\ No newline at end of file
+        ply_file.write(
+            "{} {} {} {}\n".format(vertex[0], vertex[1], vertex[2], vertex[3])
+        )