simulation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esther Max-Onakpoya on January 17th 2019\n",
    "# Script for math model stuff\n",
    "\n",
    "import math\n",
    "import numpy as np\n",
    "from scipy.stats import truncnorm\n",
    "from scipy import stats\n",
    "from collections import defaultdict\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from enum import Enum\n",
    "from matplotlib.markers import TICKDOWN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Constants\n",
    "'''\n",
    "### Physical Network\n",
    "ftToMile = 1 / 5280\n",
    "sqftToSqmi = ftToMile * ftToMile\n",
    "countyArea = 278  # 278 Sqmiles\n",
    "cityArea = 2.409  # size in sq miles\n",
    "totalPatientsInCounty = 19  # 19 patients\n",
    "totalPeopleInCounty = 12228\n",
    "OwingsvillePopulation_2 = 1488\n",
    "min_patient_number = 2\n",
    "max_patient_number = .6 * 1488\n",
    "estimatedPatientsInSampleCity = round(\n",
    "    19 * OwingsvillePopulation_2 / totalPeopleInCounty)  # lower limit of data carriers\n",
    "OwingsvillePopulation = math.floor(.269 * OwingsvillePopulation_2)\n",
    "# higher limit of data carriers https://datausa.io/profile/geo/owingsville-ky/#category_age\n",
    "bluetoothRange = 800 * ftToMile  # 800feet working in miles though\n",
    "bluetoothArea = math.pi * (bluetoothRange ** 2)\n",
    "meterInFt = 3.28084\n",
    "lowerTransmissionFactor = 0.25\n",
    "upperTransmissionFactor = 0.75  # conservative major quartile\n",
    "roomUnitSize = 100 * sqftToSqmi  # size of each cell in grid ~ 10ft*10ft\n",
    "gridLength = math.ceil(math.sqrt(cityArea / roomUnitSize))\n",
    "grid = np.zeros(shape=(gridLength, gridLength))  # 820*820\n",
    "walking_speed = 265.092 * ftToMile  # per min https://core.ac.uk/download/pdf/82652123.pdf\n",
    "walking_speed_grid = 26.5  # grid per min https://core.ac.uk/download/pdf/82652123.pdf\n",
    "densely_covered_region = 0.66\n",
    "cancer_patient_estimate = round(82*(1488/12228))\n",
    "radius_mean = 60\n",
    "radius_std = 20\n",
    "radius_lower = 20\n",
    "radius_upper = 80\n",
    "\n",
    "### Cost\n",
    "battery_life_average = 22.6  # hours https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7983341\n",
    "battery_life_std = 10\n",
    "storage_minimum = 1000  # in megabit\n",
    "message_size = 8 # 0.00112  # in megabit\n",
    "energy_consumption_rate_min = 0.15  # in J/ megabit\n",
    "energy_consumption_rate_max = 1.13  # in J/ megabit\n",
    "energy_consumption_rate_max_dtn = (energy_consumption_rate_min+energy_consumption_rate_max)/2  # in J/ megabit\n",
    "# cost_incurred_device = 0.002 # $/ megabit\n",
    "cost_incurred_connectivity = 0.002 # $/ megabit\n",
    "cost_participant_acquisition = 0 # flat fee\n",
    "battery_life_min = 0\n",
    "battery_life_max = 70\n",
    "speed_incentive_constant = 10 # r\n",
    "speed_incentive_fraction = 0.2 # F\n",
    "satellite_cost_per_day = 50/30 # https://www.exede.com/plan-results/liberty12-unlimited/\n",
    "\n",
    "\n",
    "# Probabilities\n",
    "number_of_ind_reps = 50\n",
    "seed_start = 150\n",
    "seed_array = list(range(0, 100))\n",
    "start_time_array = [6.5, 9.5, 16.5, 19]\n",
    "duration = 24\n",
    "significance_level = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CellConnectivity(Enum):\n",
    "    NONE = 0\n",
    "    BLUETOOTH = 1\n",
    "    INTERNET_ROUTER = 2\n",
    "    INTERNET_CELL = 3\n",
    "    # https://www.lifewire.com/range-of-typical-wifi-network-816564\n",
    "\n",
    "\n",
    "class NodeType(Enum):\n",
    "    PATIENT = 1\n",
    "    CAREGIVER = 2\n",
    "    INTERMEDIARY = 3\n",
    "    CLINICAL_STAFF = 4\n",
    "    DESTINATION = 5\n",
    "\n",
    "class AnalysisType(Enum):\n",
    "    DTN = 0\n",
    "    HYBRID = 1\n",
    "    INTERNET = 2\n",
    "\n",
    "class FilePresent(Enum):\n",
    "    YES = 1\n",
    "    NO = 0\n",
    "\n",
    "\n",
    "class Location:\n",
    "    def __init__(self, xcord, ycord):\n",
    "        self.xcord = xcord\n",
    "        self.ycord = ycord\n",
    "\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, id, home, location, connectivity, node_type, file_present, employment_location):\n",
    "        self.id = id\n",
    "        self.home = home\n",
    "        self.location = location\n",
    "        self.connectivity = connectivity\n",
    "        self.node_type = node_type\n",
    "        self.file_present = file_present\n",
    "        self.employment_location = employment_location\n",
    "\n",
    "\n",
    "class Cost:\n",
    "    def __init__(self, dtn, hybrid, internet):\n",
    "        self.dtn = dtn\n",
    "        self.hybrid = hybrid\n",
    "        self.internet = internet\n",
    "\n",
    "\n",
    "class transmission_cost_params:\n",
    "    def __init__(self, node_battery_life, node_energy_dtn, node_energy, node_data, node_memory):\n",
    "        self.node_battery_life = node_battery_life\n",
    "        self.node_energy_dtn = node_energy_dtn\n",
    "        self.node_energy = node_energy\n",
    "        self.node_data = node_data\n",
    "        self.node_memory = node_memory\n",
    "\n",
    "\n",
    "class DeliveryTime:\n",
    "    def __init__(self, dtn_mean, hybrid_mean, internet_mean, dtn_median, hybrid_median, internet_median):\n",
    "        self.dtn_mean = dtn_mean\n",
    "        self.hybrid_mean = hybrid_mean\n",
    "        self.internet_mean = internet_mean\n",
    "        self.dtn_median = dtn_median\n",
    "        self.hybrid_median = hybrid_median\n",
    "        self.internet_median = internet_median\n",
    "\n",
    "\n",
    "class DeliveryProbability:\n",
    "    def __init__(self, dtn, hybrid, internet):\n",
    "        self.dtn = dtn\n",
    "        self.hybrid = hybrid\n",
    "        self.internet = internet\n",
    "\n",
    "\n",
    "class GraphObject:\n",
    "    def __init__(self, dtn, hybrid, internet, markings):\n",
    "        self.dtn = dtn\n",
    "        self.hybrid = hybrid\n",
    "        self.internet = internet\n",
    "        self.markings = markings\n",
    "\n",
    "\n",
    "class LabelObject:\n",
    "    def __init__(self, x_label, y_label, title, x_ticks_tuple):\n",
    "        self.x_label = x_label\n",
    "        self.y_label = y_label\n",
    "        self.title = title\n",
    "        self.x_ticks_tuple = x_ticks_tuple\n",
    "\n",
    "\n",
    "class VariedParameter(Enum):\n",
    "    patients = 'Number of Patients'\n",
    "    ratio = 'Ratio of Population Participating in Network'\n",
    "\n",
    "    \n",
    "class CostGraphParams:\n",
    "    def __init__(self, local_cost, local_cost_err, local_cost_label, additional_data_dict):\n",
    "        self.local_cost = local_cost\n",
    "        self.local_cost_err = local_cost_err\n",
    "        self.local_cost_label = local_cost_label\n",
    "        self.additional_data_dict = additional_data_dict\n",
    "\n",
    "        \n",
    "class GraphParams:\n",
    "    def __init__(self, local, local_err, local_label):\n",
    "        self.local = local\n",
    "        self.local_err = local_err\n",
    "        self.local_label = local_label\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def isWithinCircle(source_loc, source_radius, relay_loc, relay_radius):\n",
    "    result = 0\n",
    "    distance = math.sqrt(((source_loc.xcord - relay_loc.xcord) ** 2) + ((source_loc.ycord - relay_loc.ycord) ** 2))\n",
    "    if min(source_radius, relay_radius) >= distance:\n",
    "        result = 1\n",
    "    return result\n",
    "\n",
    "\n",
    "# Generating Intermediary Nodes\n",
    "employment_location_xcord_seed = []\n",
    "employment_location_ycord_seed = []\n",
    "def generateIntermediaryNodes(ratio, srcs_number):\n",
    "    counter = 1\n",
    "    if_counter = 0\n",
    "    node_name_array = []\n",
    "    intermediary_node_array = []\n",
    "    initial_location = np.random.randint(0, gridLength, round(ratio * (math.sqrt(OwingsvillePopulation - srcs_number))))\n",
    "    initial_location.sort()\n",
    "    employment_location_xcord_seed.extend(np.random.randint(0, gridLength, 30))\n",
    "    employment_location_ycord_seed.extend(np.random.randint(0, gridLength, 30))\n",
    "    for node_initial_loc_x in initial_location:\n",
    "        for node_initial_loc_y in initial_location:\n",
    "            node_name = \"intermediary_node\" + str(counter)\n",
    "            node_name_array = [node_name_array, node_name]\n",
    "            current_node_initial_loc = Location(node_initial_loc_x, node_initial_loc_y)\n",
    "            current_nodetype = NodeType.INTERMEDIARY\n",
    "            current_node_connectivity = CellConnectivity.BLUETOOTH\n",
    "            current_node_employment_loc = Location(-1, -1)\n",
    "            destination_location = Location(round(gridLength / 2), round(gridLength / 2))\n",
    "            med_counter = 0\n",
    "            rand_value = np.random.random()\n",
    "            if counter % 5 == 0:\n",
    "                current_node_connectivity = CellConnectivity.INTERNET_CELL\n",
    "            if counter % 15 != 0:\n",
    "                # https://fred.stlouisfed.org/series/KYBATH1URN ~6.5% unemployment rate\n",
    "                current_node_employment_loc = Location(employment_location_xcord_seed[if_counter],\n",
    "                                                       employment_location_ycord_seed[if_counter])\n",
    "                if_counter += 1\n",
    "                if if_counter == 26:\n",
    "                    if_counter = 0\n",
    "               \n",
    "            if med_counter < 2 and rand_value > 0.7:\n",
    "                # https://www.govinfo.gov/content/pkg/CFR-2017-title42-vol5/xml/CFR-2017-title42-vol5-sec491-8.xml ~rural clinics must have at least 2 people\n",
    "                current_nodetype = NodeType.CLINICAL_STAFF\n",
    "                current_node_employment_loc = destination_location\n",
    "                med_counter += 1\n",
    "\n",
    "            files_contained = []\n",
    "            files_contained_index = 0\n",
    "            while files_contained_index < srcs_number:\n",
    "                files_contained.append(FilePresent.NO)\n",
    "                files_contained_index += 1\n",
    "\n",
    "            currently_generated_node = Node(node_name, current_node_initial_loc, current_node_initial_loc,\n",
    "                                            current_node_connectivity, current_nodetype,\n",
    "                                            files_contained, current_node_employment_loc)\n",
    "            # http://www.pewinternet.org/fact-sheet/internet-broadband/ ~1 in 5 rural americans have cell as their\n",
    "            # primary internet connectivity\n",
    "            counter += 1\n",
    "            intermediary_node_array.append(currently_generated_node)\n",
    "\n",
    "    return intermediary_node_array\n",
    "\n",
    "def generate_patients(number_of_patients):\n",
    "    counter = 1\n",
    "    if_counter = 0\n",
    "    if_counter_caregiver = 6\n",
    "    node_name_array = []\n",
    "    patient_array = []\n",
    "    caregiver_array = []\n",
    "    # https://www.cdc.gov/chronicdisease/index.htm\n",
    "\n",
    "    initial_location = np.random.randint(0, gridLength, math.floor(math.sqrt(number_of_patients)))\n",
    "    initial_location.sort()\n",
    "\n",
    "    for node_initial_loc_x in initial_location:\n",
    "        for node_initial_loc_y in initial_location:\n",
    "            node_name = \"patient\" + str(counter)\n",
    "            node_name_caregiver = \"caregiver\" + str(counter)\n",
    "            # node_name_array = node_name_array.append(node_name)\n",
    "            current_node_initial_loc = Location(node_initial_loc_x, node_initial_loc_y)\n",
    "            current_nodetype = NodeType.PATIENT\n",
    "            caregiver_current_nodetype = NodeType.CAREGIVER\n",
    "            current_node_connectivity = CellConnectivity.BLUETOOTH\n",
    "            current_node_employment_loc = Location(-1, -1)\n",
    "            current_node_employment_loc_caregiver = current_node_employment_loc\n",
    "            med_counter = 0\n",
    "            rand_value = np.random.random()\n",
    "            if counter % 10 == 0:  # 20 percent caregiver + patient\n",
    "                current_node_connectivity = CellConnectivity.INTERNET_CELL\n",
    "            if counter % 15 != 0 and counter > 2:  # first 2 patients are unemployed in the begining mdel\n",
    "                # https://fred.stlouisfed.org/series/KYBATH1URN ~6.5% unemployment rate\n",
    "                current_node_employment_loc = Location(employment_location_xcord_seed[if_counter],\n",
    "                                                       employment_location_ycord_seed[if_counter])\n",
    "                current_node_employment_loc_caregiver = Location(employment_location_xcord_seed[if_counter_caregiver],\n",
    "                                                                 employment_location_ycord_seed[if_counter_caregiver])\n",
    "                if_counter += 1\n",
    "                if if_counter == 26:  # 26 POIs\n",
    "                    if_counter = 0\n",
    "                if_counter_caregiver += 1\n",
    "                if if_counter_caregiver == 26:  # 26 POIs\n",
    "                    if_counter_caregiver = 0\n",
    "                # print(\"currently generated node: \", current_node_employment_loc.ycord, current_node_employment_loc.xcord)\n",
    "\n",
    "            files_contained = []\n",
    "            files_contained_index = 0\n",
    "            while files_contained_index < number_of_patients:\n",
    "                if files_contained_index == counter-1:\n",
    "                    files_contained.append(FilePresent.YES)\n",
    "                else:\n",
    "                    files_contained.append(FilePresent.NO)\n",
    "                files_contained_index += 1\n",
    "\n",
    "            currently_generated_node = Node(node_name, current_node_initial_loc, current_node_initial_loc,\n",
    "                                            current_node_connectivity, current_nodetype,\n",
    "                                            files_contained, current_node_employment_loc)\n",
    "            currently_generated_node_caregiver = Node(node_name_caregiver, current_node_initial_loc,\n",
    "                                                      current_node_initial_loc,\n",
    "                                                      current_node_connectivity, caregiver_current_nodetype,\n",
    "                                                      files_contained, current_node_employment_loc_caregiver)\n",
    "            # http://www.pewinternet.org/fact-sheet/internet-broadband/ ~1 in 5 rural americans have cell as their\n",
    "            # primary internet connectivity\n",
    "            counter += 1\n",
    "            patient_array.append(currently_generated_node)\n",
    "            caregiver_array.append(currently_generated_node_caregiver)\n",
    "\n",
    "    while counter < number_of_patients + 1:\n",
    "        extra_xcord = np.random.randint(1, 820)\n",
    "        extra_ycord = np.random.randint(1, 820)\n",
    "        current_node_initial_loc = Location(extra_xcord, extra_ycord)\n",
    "        employment_loc = Location(-1, -1)\n",
    "        node_name = \"Patient\" + str(counter)\n",
    "        node_name_caregiver = \"caregiver\" + str(counter)\n",
    "        current_node_connectivity = CellConnectivity.BLUETOOTH\n",
    "        if counter % 10 == 0:  # 20 percent caregiver + patient\n",
    "            current_node_connectivity = CellConnectivity.INTERNET_CELL\n",
    "\n",
    "        files_contained = []\n",
    "        files_contained_index = 0\n",
    "        while files_contained_index < number_of_patients:\n",
    "            if files_contained_index == counter:\n",
    "                files_contained.append(FilePresent.YES)\n",
    "            else:\n",
    "                files_contained.append(FilePresent.NO)\n",
    "            files_contained_index += 1\n",
    "\n",
    "        currently_generated_node = Node(node_name, current_node_initial_loc, current_node_initial_loc,\n",
    "                                        current_node_connectivity, NodeType.PATIENT,\n",
    "                                        files_contained, employment_loc)\n",
    "        currently_generated_node_caregiver = Node(node_name_caregiver, current_node_initial_loc,\n",
    "                                                  current_node_initial_loc,\n",
    "                                                  current_node_connectivity, NodeType.CAREGIVER,\n",
    "                                                  files_contained, employment_loc)\n",
    "        # http://www.pewinternet.org/fact-sheet/internet-broadband/ ~1 in 5 rural americans have cell as their\n",
    "        # primary internet connectivity\n",
    "\n",
    "        counter += 1\n",
    "        patient_array.append(currently_generated_node)\n",
    "        caregiver_array.append(currently_generated_node_caregiver)\n",
    "\n",
    "    if number_of_patients == 2:\n",
    "        patient_array = []\n",
    "        caregiver_array = []\n",
    "        employment_loc = Location(-1, -1)\n",
    "        patient1_location = Location(0, gridLength)\n",
    "        patient2_location = Location(gridLength, gridLength)\n",
    "        patient1 = Node(\"patient1\", patient1_location, patient1_location, CellConnectivity.BLUETOOTH, NodeType.PATIENT,\n",
    "                        [FilePresent.YES, FilePresent.NO], employment_loc)\n",
    "        patient2 = Node(\"patient2\", patient2_location, patient2_location, CellConnectivity.BLUETOOTH, NodeType.PATIENT,\n",
    "                        [FilePresent.NO, FilePresent.YES], employment_loc)\n",
    "        caregiver1 = Node(\"caregiver1\", patient1_location, patient1.location, CellConnectivity.BLUETOOTH,\n",
    "                          NodeType.CAREGIVER,\n",
    "                          [FilePresent.YES, FilePresent.NO], employment_loc)\n",
    "        caregiver2 = Node(\"caregiver2\", patient2.location, patient2.location, CellConnectivity.BLUETOOTH,\n",
    "                          NodeType.CAREGIVER,\n",
    "                          [FilePresent.NO, FilePresent.YES], employment_loc)\n",
    "        patient_array.append(patient1)\n",
    "        patient_array.append(patient2)\n",
    "        caregiver_array.append(caregiver1)\n",
    "        caregiver_array.append(caregiver2)\n",
    "    return caregiver_array, patient_array\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Settings\n",
    "\"\"\"\n",
    "\n",
    "def trunc_normal_dist(mean, sd, low, upp, n=1):\n",
    "    x = truncnorm((low - mean) / sd, (upp - mean) / sd, loc=mean, scale=sd)\n",
    "    return x.rvs(n)\n",
    "\n",
    "\n",
    "def try_int(x):\n",
    "    try:\n",
    "        return int(x)\n",
    "    except ValueError:\n",
    "        return None\n",
    "\n",
    "\n",
    "def file_present_array(patient_array, caregiver_array):\n",
    "    file_present = []\n",
    "    index = 0\n",
    "    while index < len(patient_array):\n",
    "        file_present_temp = []\n",
    "        file_present_temp.extend((patient_array[index], caregiver_array[index]))\n",
    "        file_present.append(file_present_temp)\n",
    "        index += 1\n",
    "    return file_present\n",
    "\n",
    "\n",
    "def file_absent_array(intermediary_node_array, number_of_patients):\n",
    "    file_absent = []\n",
    "    index = 0\n",
    "    while index < number_of_patients:\n",
    "        file_absent_temp = []\n",
    "        file_absent_temp.extend(intermediary_node_array)\n",
    "        file_absent.append(file_absent_temp)\n",
    "        index += 1\n",
    "    return file_absent\n",
    "\n",
    "\n",
    "def traveling_function(speed, time, destination_point, src_point):\n",
    "    distance_covered = speed * time\n",
    "    current_location = destination_point\n",
    "    \n",
    "    del_x = destination_point.xcord - src_point.xcord\n",
    "    del_y = destination_point.ycord - src_point.ycord\n",
    "    distance_src_dest = math.sqrt((del_x ** 2) + (del_y ** 2))\n",
    "    \n",
    "    if distance_src_dest > 0:\n",
    "        new_xcord = math.floor((distance_covered * del_x / distance_src_dest) + src_point.xcord)\n",
    "        new_ycord = math.floor((distance_covered * del_y / distance_src_dest) + src_point.ycord)\n",
    "        current_location = Location(new_xcord, new_ycord)\n",
    "    return current_location\n",
    "\n",
    "\n",
    "def changeLocation(node, period, current_time):\n",
    "    # http://oatao.univ-toulouse.fr/4526/1/Nguyen_4526.pdf\n",
    "    \n",
    "    employment_location_xcord_seed = np.random.randint(0, gridLength, 30)\n",
    "    employment_location_ycord_seed = np.random.randint(0, gridLength, 30)\n",
    "    state_var = np.random.random()\n",
    "    random_poi = np.random.randint(0, 24)\n",
    "    if period == 1:\n",
    "        # 19-6 Using probablities at 19 hours\n",
    "        period_start_time = 19\n",
    "        if current_time == period_start_time: #Initial Probabilities\n",
    "            home_probability_fulltime = 0.704697987\n",
    "            work_probability_fulltime = 0.079418345\n",
    "            poi_probability_fulltime = 0.215883669\n",
    "            home_probability_unemp = 0.850498339\n",
    "            work_probability_unemp = 0\n",
    "            poi_probability_unemp = 0.149501661\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0:\n",
    "                if state_var > home_probability_unemp:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    node.location = node.home\n",
    "            else:\n",
    "                if state_var < home_probability_fulltime:\n",
    "                    node.location = node.home\n",
    "                elif state_var < (home_probability_fulltime+work_probability_fulltime):\n",
    "                    node.location = node.employment_location\n",
    "                else:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "        else: #Transition matrix\n",
    "            home_to_home_unemp = 0.94\n",
    "            home_to_poi_unemp = 0.064\n",
    "            poi_to_home_unemp = 0.37\n",
    "            poi_to_poi_unemp = 0.63\n",
    "            ##\n",
    "            home_to_home_emp = 0.85416667\n",
    "            home_to_work_emp = 0.01875\n",
    "            home_to_poi_emp = 0.12708333\n",
    "            work_to_home_emp = 0.14285714\n",
    "            work_to_work_emp = 0.81428571\n",
    "            poi_to_home_emp = 0.38961039\n",
    "            poi_to_poi_emp = 0.57792208\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0: # check where unemployed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var > home_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "                else:\n",
    "                    if state_var > poi_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "            else:  # check where employed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var < home_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (home_to_home_emp + home_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                elif node.location == node.employment_location:\n",
    "                    if state_var < work_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (work_to_home_emp + work_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    if state_var < poi_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (poi_to_home_emp + poi_to_poi_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "    if period == 2:\n",
    "        # 19-6 Using probablities at 19 hours\n",
    "\n",
    "        period_start_time = 6.5\n",
    "        if current_time == period_start_time: #Initial Probabilities\n",
    "            home_probability_fulltime = 0.708759954\n",
    "            work_probability_fulltime = 0.160409556\n",
    "            poi_probability_fulltime = 0.130830489\n",
    "            home_probability_unemp = 0.930394432\n",
    "            poi_probability_unemp = 0.069605568\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0:\n",
    "                if state_var > home_probability_unemp:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    node.location = node.home\n",
    "            else:\n",
    "                if state_var < home_probability_fulltime:\n",
    "                    node.location = node.home\n",
    "                elif state_var < (home_probability_fulltime+work_probability_fulltime):\n",
    "                    node.location = node.employment_location\n",
    "                else:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "        else: #Transition matrix\n",
    "            home_to_home_unemp = 0.97\n",
    "            poi_to_home_unemp = 0.59\n",
    "            ##\n",
    "            home_to_home_emp = 0.85968379\n",
    "            home_to_work_emp = 0.07905138\n",
    "            work_to_home_emp = 0.17037037\n",
    "            work_to_work_emp = 0.61481481\n",
    "            poi_to_home_emp = 0.5060241\n",
    "            poi_to_poi_emp = 0.31325301\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0: # check where unemployed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var > home_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "                else:\n",
    "                    if state_var > poi_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "            else:  # check where employed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var < home_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (home_to_home_emp + home_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                elif node.location == node.employment_location:\n",
    "                    if state_var < work_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (work_to_home_emp + work_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    if state_var < poi_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (poi_to_home_emp + poi_to_poi_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "    if period == 3:\n",
    "        # 19-6 Using probablities at 19 hours\n",
    "        period_start_time = 9.5\n",
    "        if current_time == period_start_time: #Initial Probabilities\n",
    "            home_probability_fulltime = 0.436090226\n",
    "            work_probability_fulltime = 0.34962406\n",
    "            home_probability_unemp = 0.762954796\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0:\n",
    "                if state_var > home_probability_unemp:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    node.location = node.home\n",
    "            else:\n",
    "                if state_var < home_probability_fulltime:\n",
    "                    node.location = node.home\n",
    "                elif state_var < (home_probability_fulltime+work_probability_fulltime):\n",
    "                    node.location = node.employment_location\n",
    "                else:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "        else: #Transition matrix\n",
    "            home_to_home_unemp = 0.89\n",
    "            poi_to_home_unemp = 0.36\n",
    "            ##\n",
    "            home_to_home_emp = 0.80066445\n",
    "            home_to_work_emp = 0.08305648\n",
    "            work_to_home_emp = 0.06296296\n",
    "            work_to_work_emp = 0.9\n",
    "            poi_to_home_emp = 0.30081301\n",
    "            poi_to_poi_emp = 0.64227642\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0: # check where unemployed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var > home_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "                else:\n",
    "                    if state_var > poi_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "            else:  # check where employed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var < home_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (home_to_home_emp + home_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                elif node.location == node.employment_location:\n",
    "                    if state_var < work_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (work_to_home_emp + work_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    if state_var < poi_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (poi_to_home_emp + poi_to_poi_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "    if period == 4:\n",
    "        # 19-6 Using probablities at 19 hours\n",
    "        period_start_time = 16.5\n",
    "        if current_time == period_start_time: #Initial Probabilities\n",
    "            home_probability_fulltime = 0.479713604\n",
    "            work_probability_fulltime = 0.19928401\n",
    "            home_probability_unemp = 0.770345596\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0:\n",
    "                if state_var > home_probability_unemp:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    node.location = node.home\n",
    "            else:\n",
    "                if state_var < home_probability_fulltime:\n",
    "                    node.location = node.home\n",
    "                elif state_var < (home_probability_fulltime+work_probability_fulltime):\n",
    "                    node.location = node.employment_location\n",
    "                else:\n",
    "                    node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "        else: #Transition matrix\n",
    "            home_to_home_unemp = 0.91\n",
    "            poi_to_home_unemp = 0.30\n",
    "            ##\n",
    "            home_to_home_emp = 0.80118694\n",
    "            home_to_work_emp = 0.02670623\n",
    "            work_to_home_emp = 0.04216867\n",
    "            work_to_work_emp = 0.87951807\n",
    "            poi_to_home_emp = 0.2815534\n",
    "            poi_to_poi_emp = 0.66019417\n",
    "            if node.node_type == NodeType.PATIENT or node.node_type == NodeType.CAREGIVER or \\\n",
    "                    node.employment_location.xcord < 0: # check where unemployed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var > home_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "                else:\n",
    "                    if state_var > poi_to_home_unemp:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                             employment_location_ycord_seed[random_poi])\n",
    "                    else:\n",
    "                        node.location = node.home\n",
    "            else:  # check where employed nodes be\n",
    "                if node.location == node.home: # check if unemployed nodes should remain where they are or move\n",
    "                    if state_var < home_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (home_to_home_emp + home_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                elif node.location == node.employment_location:\n",
    "                    if state_var < work_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (work_to_home_emp + work_to_work_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "                else:\n",
    "                    if state_var < poi_to_home_emp:\n",
    "                        node.location = node.home\n",
    "                    elif state_var < (poi_to_home_emp + poi_to_poi_emp):\n",
    "                        node.location = node.employment_location\n",
    "                    else:\n",
    "                        node.location = Location(employment_location_xcord_seed[random_poi],\n",
    "                                                 employment_location_ycord_seed[random_poi])\n",
    "\n",
    "\n",
    "def period_finder(current_time):\n",
    "    while current_time > 24:\n",
    "        current_time = current_time - 24\n",
    "    if current_time < 6.5:\n",
    "        period = 1\n",
    "    elif current_time < 9.5:\n",
    "        period = 2\n",
    "    elif current_time < 16.5:\n",
    "        period = 3\n",
    "    elif current_time < 19:\n",
    "        period = 4\n",
    "    else:\n",
    "        period = 1\n",
    "    return period\n",
    "\n",
    "\n",
    "def generate_destination(number_of_patients):\n",
    "    index = 0\n",
    "    destination_location = Location(round(gridLength / 2), round(gridLength / 2))\n",
    "    dtn_destination_file_status = []\n",
    "    hybrid_destination_file_status = []\n",
    "    internet_file_status = []\n",
    "    employment_loc = Location(-1, -1)\n",
    "    while index < number_of_patients:\n",
    "        dtn_destination_file_status.append(FilePresent.NO)\n",
    "        hybrid_destination_file_status.append(FilePresent.NO)\n",
    "        internet_file_status.append(FilePresent.NO)\n",
    "        index += 1\n",
    "    destination = Node(\"destination\", destination_location, destination_location, CellConnectivity.INTERNET_ROUTER,\n",
    "                       NodeType.DESTINATION,\n",
    "                       [dtn_destination_file_status, hybrid_destination_file_status, internet_file_status], employment_loc)# for DTN and hybrid\n",
    "    return destination\n",
    "\n",
    "\n",
    "def move(current_time, node, node_id_loc_dict):\n",
    "    # check if node.id is in the list\n",
    "    if node.id in node_id_loc_dict:\n",
    "        node.location = node_id_loc_dict[node.id]\n",
    "\n",
    "    else:\n",
    "        period = period_finder(current_time)\n",
    "        changeLocation(node, period, current_time)\n",
    "        node_id_loc_dict[node.id] = node.location\n",
    "\n",
    "\n",
    "def calculateCost(analysisType, node, transmission_cost_params_dict, cost_incurred_device):\n",
    "    initial_participation = False\n",
    "    \n",
    "    if node.id not in transmission_cost_params_dict:\n",
    "        node_battery_life = trunc_normal_dist(battery_life_average, battery_life_std, battery_life_min,\n",
    "                                          battery_life_max, n=1)\n",
    "        node_energy_dtn = trunc_normal_dist((energy_consumption_rate_min + energy_consumption_rate_max_dtn) / 2,\n",
    "                                            (energy_consumption_rate_min + energy_consumption_rate_max_dtn) / 4,\n",
    "                                            energy_consumption_rate_min, energy_consumption_rate_max_dtn, n=1)\n",
    "        node_energy = trunc_normal_dist((energy_consumption_rate_min + energy_consumption_rate_max) / 2,\n",
    "                                            (energy_consumption_rate_min + energy_consumption_rate_max) / 4,\n",
    "                                            energy_consumption_rate_min, energy_consumption_rate_max, n=1)\n",
    "        node_data = 1\n",
    "        node_memory = storage_minimum\n",
    "        transmission_cost_params_dict[node.id] = transmission_cost_params(node_battery_life, node_energy_dtn,\n",
    "                                                                          node_energy, node_data, node_memory)\n",
    "        initial_participation = True\n",
    "        \n",
    "    if initial_participation:\n",
    "        transmission_cost = cost_participant_acquisition\n",
    "    else:\n",
    "        transmission_cost = 0\n",
    "        \n",
    "    if analysisType == AnalysisType.DTN:\n",
    "        upsilon = (transmission_cost_params_dict[node.id].node_battery_life/battery_life_max) + \\\n",
    "                  (transmission_cost_params_dict[node.id].node_energy_dtn/energy_consumption_rate_max_dtn) + \\\n",
    "                  (message_size/transmission_cost_params_dict[node.id].node_memory)\n",
    "        transmission_cost = transmission_cost + (cost_incurred_device/upsilon)\n",
    "    elif analysisType == AnalysisType.HYBRID:\n",
    "        upsilon = (transmission_cost_params_dict[node.id].node_battery_life / battery_life_max) + \\\n",
    "                  (transmission_cost_params_dict[node.id].node_energy / energy_consumption_rate_max) + \\\n",
    "                  (message_size / transmission_cost_params_dict[node.id].node_memory)\n",
    "        transmission_cost =  transmission_cost + (cost_incurred_device/upsilon)+\\\n",
    "                            (cost_incurred_connectivity / transmission_cost_params_dict[node.id].node_data)\n",
    "    elif analysisType == AnalysisType.INTERNET:\n",
    "        upsilon = (transmission_cost_params_dict[node.id].node_battery_life / battery_life_max) + \\\n",
    "                  (transmission_cost_params_dict[node.id].node_energy / energy_consumption_rate_max) + \\\n",
    "                  (message_size / transmission_cost_params_dict[node.id].node_memory)\n",
    "        transmission_cost =  transmission_cost + (cost_incurred_device/upsilon)+\\\n",
    "                            (cost_incurred_connectivity / transmission_cost_params_dict[node.id].node_data)\n",
    "    else:\n",
    "        raise Exception(\"Calculate Cost does not enter analysis type\")\n",
    "\n",
    "    return transmission_cost, upsilon\n",
    "\n",
    "\n",
    "def calculateSpeedIncentive(time, start_time, duration, upsilon):\n",
    "    val = upsilon[0].item()\n",
    "    a = (cost_incurred_connectivity / val)\n",
    "    b = ((time - start_time) * math.log(speed_incentive_constant * cost_incurred_connectivity))\n",
    "    c = (1 - duration)\n",
    "    d = math.exp(b/c)\n",
    "    e = speed_incentive_fraction + d\n",
    "    speed_incentive = e * a\n",
    "    if speed_incentive < 0:\n",
    "        print(speed_incentive)\n",
    "\n",
    "    return speed_incentive\n",
    "\n",
    "\n",
    "def i_cant_shout_sum(list):\n",
    "    list_index = 0\n",
    "    list_sum = 0\n",
    "    while list_index < len(list):\n",
    "        list_sum = list_sum + list[list_index]\n",
    "        list_index += 1\n",
    "    return list_sum\n",
    "\n",
    "\n",
    "def problemOne(number_of_patients, ratio, start_time, duration):\n",
    "    patient_array, caregiver_array = generate_patients(number_of_patients)\n",
    "    intermediary_node_array = generateIntermediaryNodes(ratio, number_of_patients)\n",
    "    file_present = file_present_array(patient_array, caregiver_array)\n",
    "    file_absent = file_absent_array(intermediary_node_array, number_of_patients)\n",
    "    destination = generate_destination(number_of_patients)\n",
    "\n",
    "    t_0 = start_time\n",
    "    t_step = 0.5\n",
    "    t_f = duration + t_0\n",
    "    radius = trunc_normal_dist(radius_mean, radius_std, radius_lower, radius_upper, n=1)[0]\n",
    "    radius_2 = trunc_normal_dist(radius_mean, radius_std, radius_lower, radius_upper, n=1)[0]  \n",
    "\n",
    "    cost_incurred_device = cost_incurred_connectivity/(ratio*OwingsvillePopulation)\n",
    "\n",
    "    current_time = t_0\n",
    "    node_id_loc_dict = {}\n",
    "    transmission_cost_params_dict = {} # key: node_id value: [energy, battery, memory, data]\n",
    "    delivery_rate = 0\n",
    "    hybrid_delivery_rate = 0\n",
    "    hybrid_counter = 0\n",
    "    time_delivered = 0\n",
    "    time_delivered_array = []\n",
    "    hybrid_time_delivered_array = []\n",
    "    hybrid_time_delivered = 0\n",
    "    transmitted_messages = 0\n",
    "    transmitted_messages_array = [0] * number_of_patients\n",
    "    hybrid_transmitted_messages = 0\n",
    "    delivery_probabilities = []\n",
    "    hybrid_delivery_probabilities = []\n",
    "    files_in_destination = 0\n",
    "    files_in_destination_hybrid = 0\n",
    "    files_in_destination_internet = 0\n",
    "    hybrid_index_list = []\n",
    "    time_index = 0\n",
    "    internet_time_delivered_array = []\n",
    "    internet_index_list = []\n",
    "    internet_delivery_probabilities = []\n",
    "    delivery_time = DeliveryTime(0, 0, 0, 0, 0, 0)\n",
    "    cost = Cost(0, 0, 0)\n",
    "    delivery_probability = DeliveryProbability(0, 0, 0)\n",
    "\n",
    "    dtn_cost = [0] * number_of_patients\n",
    "    hybrid_cost = [0] * number_of_patients # internet set up cost for destination\n",
    "    internet_cost = satellite_cost_per_day # internet set up cost for destination\n",
    "\n",
    "    if current_time == t_0:\n",
    "        index = 0\n",
    "        period_1 = period_finder(current_time)\n",
    "        while index < number_of_patients:\n",
    "            for node_i in file_present[index]:\n",
    "                changeLocation(node_i, period_1, current_time)\n",
    "            for node_j in file_absent[index]:\n",
    "                changeLocation(node_j, period_1, current_time)\n",
    "            index += 1\n",
    "\n",
    "    while current_time < t_f:  # changes time step to get to destination\n",
    "        p1_index = 0\n",
    "        while p1_index < number_of_patients:  # transmits each patients information; change node location after this\n",
    "\n",
    "            if destination.file_present[0][\n",
    "                p1_index] == FilePresent.NO:  # checks if the current patients file is not at destination\n",
    "\n",
    "                for node_i in file_present[p1_index]:\n",
    "                    for node_j in file_absent[p1_index]:\n",
    "                        if isWithinCircle(node_i.location, radius, node_j.location, radius_2) != 0:\n",
    "                            node_j.file_present[p1_index] = FilePresent.YES\n",
    "                            transmitted_messages += 1\n",
    "                            transmitted_messages_array[p1_index] = transmitted_messages_array[p1_index] + 1\n",
    "\n",
    "                            # Cost analysis\n",
    "\n",
    "                            #### DTN ####\n",
    "                            if node_i.node_type != NodeType.PATIENT:\n",
    "                                trans_cost_dtn, upsilon_dtn = calculateCost(AnalysisType.DTN, node_i,\n",
    "                                                                    transmission_cost_params_dict, cost_incurred_device)\n",
    "                                dtn_cost[p1_index] = dtn_cost[p1_index]+trans_cost_dtn\n",
    "\n",
    "                            #### Hybrid ####\n",
    "                            if node_j.connectivity == CellConnectivity.INTERNET_CELL:\n",
    "                                if destination.file_present[1][p1_index] == FilePresent.NO:\n",
    "                                    destination.file_present[1][p1_index] = FilePresent.YES \n",
    "                                    hybrid_counter += 1\n",
    "                                    hybrid_time_delivered = current_time - t_0\n",
    "                                    hybrid_time_delivered_array.append(hybrid_time_delivered)\n",
    "                                    hybrid_transmitted_messages = hybrid_transmitted_messages + transmitted_messages_array[p1_index]\n",
    "                                    hybrid_index_list.append(p1_index)\n",
    "                                    trans_cost_hy, upsilon_hy = calculateCost(AnalysisType.HYBRID, node_j,\n",
    "                                                                    transmission_cost_params_dict, cost_incurred_device)\n",
    "                                    hybrid_cost[p1_index] = trans_cost_hy + dtn_cost[p1_index]+\\\n",
    "                                                            calculateSpeedIncentive(current_time, start_time,\n",
    "                                                                                    duration, upsilon_hy)# added speed incentive cost here\n",
    "\n",
    "                            #### Internet ####\n",
    "                            if node_j.connectivity == CellConnectivity.INTERNET_CELL and \\\n",
    "                                    node_i.node_type == NodeType.PATIENT:\n",
    "                                if destination.file_present[2][p1_index] == FilePresent.NO:\n",
    "                                    destination.file_present[2][p1_index] = FilePresent.YES\n",
    "                                    internet_time_delivered = current_time - t_0\n",
    "                                    internet_time_delivered_array.append(internet_time_delivered)\n",
    "                                    internet_index_list.append(p1_index)\n",
    "                                    trans_cost_int, upsilon_int = calculateCost(AnalysisType.INTERNET, node_j,\n",
    "                                                                    transmission_cost_params_dict, cost_incurred_device)\n",
    "                                    internet_cost = internet_cost+trans_cost_int + calculateSpeedIncentive(current_time,\n",
    "                                                                                                           start_time,\n",
    "                                                                                                           duration,\n",
    "                                                                                                           upsilon_int) # added speed incentive cost here\n",
    "                            # switching lists\n",
    "                            file_present[p1_index].append(node_j)\n",
    "                            file_absent[p1_index].remove(node_j)\n",
    "\n",
    "                        move(current_time, node_j, node_id_loc_dict)\n",
    "\n",
    "                    if isWithinCircle(destination.location, radius, node_i.location, radius_2) != 0:\n",
    "                        trans_cost_dtn, upsilon_dtn = calculateCost(AnalysisType.DTN, node_i,\n",
    "                                                                    transmission_cost_params_dict,\n",
    "                                                                    cost_incurred_device)\n",
    "\n",
    "                        if destination.file_present[1][p1_index] == FilePresent.NO:\n",
    "                            hybrid_time_delivered = current_time - t_0 # change to minue\n",
    "                            hybrid_time_delivered_array.append(hybrid_time_delivered)\n",
    "                            destination.file_present[1][p1_index] = FilePresent.YES\n",
    "                            hybrid_cost[p1_index] = dtn_cost[p1_index]\n",
    "                            hybrid_cost[p1_index] = hybrid_cost[p1_index]+ calculateSpeedIncentive(current_time, start_time, duration, upsilon_dtn)# add speed incentive cost here\n",
    "\n",
    "                        destination.file_present[0][p1_index] = FilePresent.YES\n",
    "                        time_delivered = current_time - t_0  # change to minue\n",
    "                        time_delivered_array.append(time_delivered)\n",
    "                        transmitted_messages += 1\n",
    "                        dtn_cost[p1_index] = dtn_cost[p1_index] + calculateSpeedIncentive(current_time, start_time, duration, upsilon_dtn) # add speed incentive cost here\n",
    "\n",
    "                        if destination.file_present[2][p1_index] == FilePresent.NO and node_i.node_type == NodeType.PATIENT:\n",
    "                            internet_time_delivered = current_time - t_0 # change to minue\n",
    "                            internet_time_delivered_array.append(internet_time_delivered)\n",
    "                            destination.file_present[2][p1_index] = FilePresent.YES\n",
    "\n",
    "                    move(current_time, node_i, node_id_loc_dict)\n",
    "\n",
    "            files_in_destination = 0\n",
    "            destination_file_index = 0\n",
    "            for files in destination.file_present[0]:  # checks if all files are present in destination to return current time\n",
    "                if destination.file_present[0][destination_file_index] == FilePresent.YES:\n",
    "                    files_in_destination += 1\n",
    "                destination_file_index += 1\n",
    "\n",
    "            files_in_destination_hybrid = 0\n",
    "            destination_file_index = 0\n",
    "            for files in destination.file_present[1]:  # checks if all files are present in destination to return current time\n",
    "                if destination.file_present[1][destination_file_index] == FilePresent.YES:\n",
    "                    files_in_destination_hybrid += 1\n",
    "                destination_file_index += 1\n",
    "\n",
    "            files_in_destination_internet = 0\n",
    "            destination_file_index = 0\n",
    "            for files in destination.file_present[2]:  # checks if all files are present in destination to return current time\n",
    "                if destination.file_present[2][destination_file_index] == FilePresent.YES:\n",
    "                    files_in_destination_internet += 1\n",
    "                destination_file_index += 1\n",
    "\n",
    "            hybrid_time_delivered_median = np.median(hybrid_time_delivered_array)\n",
    "            time_delivered_median = np.median(time_delivered_array)\n",
    "            internet_time_delivered_median = np.median(internet_time_delivered_array)\n",
    "            \n",
    "            if len(hybrid_time_delivered_array) < 1:\n",
    "                hybrid_time_delivered_mean = 0\n",
    "            else:\n",
    "                hybrid_time_delivered_mean = max(hybrid_time_delivered_array)# np.mean(hybrid_time_delivered_array)\n",
    "            if len(time_delivered_array) < 1:\n",
    "                time_delivered_mean = 0\n",
    "            else:\n",
    "                time_delivered_mean = max(time_delivered_array)# np.mean(time_delivered_array)\n",
    "            if len(internet_time_delivered_array) < 1:\n",
    "                internet_time_delivered_mean = 0\n",
    "            else:\n",
    "                internet_time_delivered_mean = max(internet_time_delivered_array)# np.mean(internet_time_delivered_array)\n",
    "                \n",
    "            delivery_time = DeliveryTime(time_delivered_mean, hybrid_time_delivered_mean,\n",
    "                                        internet_time_delivered_mean, time_delivered_median, hybrid_time_delivered_median,\n",
    "                                         internet_time_delivered_median)\n",
    "            hybrid_cost_sum = sum(hybrid_cost)\n",
    "            if type(hybrid_cost_sum) is np.ndarray:\n",
    "                hybrid_cost_sum = hybrid_cost_sum.item() + satellite_cost_per_day\n",
    "            else:\n",
    "                hybrid_cost_sum = hybrid_cost_sum + satellite_cost_per_day\n",
    "\n",
    "            cost = Cost(sum(dtn_cost), hybrid_cost_sum, internet_cost)\n",
    "            delivery_probability = DeliveryProbability(files_in_destination/number_of_patients,\n",
    "                                                       files_in_destination_hybrid/number_of_patients,\n",
    "                                                       files_in_destination_internet/number_of_patients)\n",
    "\n",
    "            if files_in_destination == len(destination.file_present[0]) and files_in_destination_hybrid == \\\n",
    "                    len(destination.file_present[1]) and p1_index > 0 and files_in_destination_internet == \\\n",
    "                    len(destination.file_present[2]):\n",
    "\n",
    "                return delivery_time, cost, delivery_probability\n",
    "\n",
    "            elif files_in_destination == len(destination.file_present[0]) and files_in_destination_hybrid == \\\n",
    "                    len(destination.file_present[1]) and p1_index == 0 and files_in_destination_internet == \\\n",
    "                    len(destination.file_present[2]):\n",
    "\n",
    "                return delivery_time, cost, delivery_probability\n",
    "\n",
    "            p1_index += 1\n",
    "\n",
    "        node_id_loc_dict = {}\n",
    "\n",
    "        delivery_probabilities.append(files_in_destination/number_of_patients)\n",
    "        hybrid_delivery_probabilities.append(files_in_destination_hybrid/number_of_patients)\n",
    "\n",
    "        current_time += t_step\n",
    "        time_index += 1\n",
    "\n",
    "    return delivery_time, cost, delivery_probability\n",
    "\n",
    "\n",
    "def ttest_data(data1, data2):\n",
    "    t_stat, p_val = stats.ttest_rel(data1, data2)\n",
    "    if p_val < 0.05:\n",
    "        # averages are not equal\n",
    "        return False\n",
    "    else: return True\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_plots(bars: GraphObject, errors: GraphObject, label: LabelObject,\n",
    "               additional_data: defaultdict=defaultdict(list)):\n",
    "    \"\"\" Plot the graphs obtained\n",
    "\n",
    "\n",
    "    :param bars: This is the mean value object for 3 bars\n",
    "    :param errors: This is the standard error of mean object for 3 bars\n",
    "    :param label: This is the label object for 3 bars\n",
    "    :param there_is_additional_data: ONLY SET TO TRUE IF PLOTTING > 3 BARS\n",
    "    :param additional_data: If plotting greater than 3 bars, add a collection.defaultdict(list) with each\n",
    "           additional plot as a new list. DO NOT CHANGE VALUE WITHIN FUNCTION BELOW. TREAT AS A READ ONLY VAR.\n",
    "    :return: NONE\n",
    "    \"\"\"\n",
    "    \n",
    "    color_list = ['b', 'g', 'r', 'c', 'm']\n",
    "    # create plot\n",
    "    # https://pythonspot.com/matplotlib-bar-chart/ multi bar\n",
    "    # https://problemsolvingwithpython.com/06-Plotting-with-Matplotlib/06.07-Error-Bars/ error bar\n",
    "    fig, ax = plt.subplots()\n",
    "    index = np.arange(len(bars.markings))\n",
    "    bar_width = 0.2\n",
    "    opacity = 0.4\n",
    "    pad = 0\n",
    "\n",
    "    rects1 = plt.bar(index, bars.dtn, bar_width,\n",
    "                     alpha=opacity,\n",
    "                     color='b',\n",
    "                     label='DTN',\n",
    "                     yerr=errors.dtn,\n",
    "                     align='center',\n",
    "                     ecolor='black',\n",
    "                     capsize=25/len(bars.markings)\n",
    "                     )\n",
    "\n",
    "    rects2 = plt.bar(index + bar_width, bars.hybrid, bar_width,\n",
    "                     alpha=opacity,\n",
    "                     color='g',\n",
    "                     label='Hybrid',\n",
    "                     yerr=errors.hybrid,\n",
    "                     align='center',\n",
    "                     ecolor='black',\n",
    "                     capsize=25/len(bars.markings)\n",
    "                     )\n",
    "\n",
    "    rects3 = plt.bar(index + 2*bar_width, bars.internet, bar_width,\n",
    "                     alpha=opacity,\n",
    "                     color='r',\n",
    "                     label='UPN',\n",
    "                     yerr=errors.internet,\n",
    "                     align='center',\n",
    "                     ecolor='black',\n",
    "                     capsize=25/len(bars.markings)\n",
    "                     )\n",
    "    if len(additional_data) != 0:\n",
    "        count = 3\n",
    "        for key in additional_data.keys():\n",
    "            rects4 = plt.bar(index + count * bar_width, additional_data[key], bar_width,\n",
    "                    alpha=opacity,\n",
    "                    color='c',\n",
    "                    label=key,\n",
    "                    yerr=0,\n",
    "                    align='center',\n",
    "                    ecolor='black',\n",
    "                    capsize=25 / len(bars.markings)\n",
    "                    )\n",
    "            count += 1\n",
    "        plt.yscale('log')\n",
    "\n",
    "#     for indy in range(len(bars.dtn)):\n",
    "#         if bars.markings[indy]: # if null hypothesis is rejected\n",
    "#             for i in ax.patches:\n",
    "#                 # get_width pulls left or right; get_y pushes up or down\n",
    "#                 ax.text(i.get_width()+pad, max(bars.dtn[indy], bars.internet[indy], bars.hybrid[indy]),\n",
    "#                         str('*'), fontsize=12,\n",
    "#                         color='dimgrey')\n",
    "#         pad += 5*bar_width\n",
    "\n",
    "    plt.xlabel(label.x_label)\n",
    "    plt.ylabel(label.y_label)\n",
    "    plt.title(label.title)\n",
    "    plt.xticks(index + bar_width, label.x_ticks_tuple) # fix label object\n",
    "    plt.legend()\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_problem_one(patient: list, ratio_list: list, varied_param: VariedParameter):\n",
    "    local_cost = GraphObject([], [], [], []) #means\n",
    "    local_delay = GraphObject([], [], [], [])\n",
    "    local_delay_median = GraphObject([], [], [], [])\n",
    "    local_delivery = GraphObject([], [], [], [])\n",
    "    local_cost_err = GraphObject([], [], [], []) #sem\n",
    "    local_delay_err = GraphObject([], [], [], [])\n",
    "    local_delay_median_err = GraphObject([], [], [], [])\n",
    "    local_delivery_err = GraphObject([], [], [], [])\n",
    "    additional_data_dict = defaultdict(list)\n",
    "    additional_data_dict['Satellite'] = []\n",
    "    if len(patient) > 1 and len(ratio_list) > 1:\n",
    "        print(\"lengths\", len(patient), len(ratio_list))\n",
    "        raise Exception('You can only vary one parameter at a time')\n",
    "    if varied_param == VariedParameter.patients:\n",
    "        ticks = tuple(map(str, patient))\n",
    "    elif varied_param == VariedParameter.ratio:\n",
    "        ticks = tuple(map(str, ratio_list))\n",
    "    else:\n",
    "        raise Exception('Varied parameter is not correctly set')\n",
    "    local_cost_label = LabelObject(varied_param.value, 'Cost per 24 hours', 'Effect of ' + varied_param.value + ' on Network Cost',\n",
    "                                       ticks)\n",
    "    local_delay_label = LabelObject(varied_param.value, 'Delay (hrs)', 'Effect of ' + varied_param.value + ' on Message Delay',\n",
    "                                       ticks)\n",
    "    local_delivery_label = LabelObject(varied_param.value, 'Delivery Rate', 'Effect of ' + varied_param.value + ' on Delivery Rate',\n",
    "                                       ticks)\n",
    "\n",
    "    for patient_number in patient:\n",
    "        for ratio in ratio_list:\n",
    "            subject_count = 0\n",
    "\n",
    "            local_dict_cost = defaultdict(list)\n",
    "            local_dict_cost['Subject_ID'] = []\n",
    "            local_dict_cost['Cost'] = []\n",
    "            local_dict_cost['Network_style'] = []\n",
    "\n",
    "            local_dict_delay_mean = defaultdict(list)\n",
    "            local_dict_delay_mean['Subject_ID'] = []\n",
    "            local_dict_delay_mean['Delay'] = []\n",
    "            local_dict_delay_mean['Network_style'] = []\n",
    "\n",
    "            local_dict_delay_median = defaultdict(list)\n",
    "            local_dict_delay_median['Subject_ID'] = []\n",
    "            local_dict_delay_median['Delay'] = []\n",
    "            local_dict_delay_median['Network_style'] = []\n",
    "\n",
    "            local_dict_delivery = defaultdict(list)\n",
    "            local_dict_delivery['Subject_ID'] = []\n",
    "            local_dict_delivery['Delivery'] = []\n",
    "            local_dict_delivery['Network_style'] = []\n",
    "\n",
    "            for seed in seed_array:\n",
    "                np.random.seed(seed)\n",
    "\n",
    "                delivery_time, cost, delivery_probability = problemOne(patient_number, ratio,\n",
    "                                                                       start_time_array[\n",
    "                                                                           np.random.randint(0, len(start_time_array))],\n",
    "                                                                       duration)\n",
    "\n",
    "                if type(cost.dtn) is np.ndarray:\n",
    "                    local_dict_cost['Cost'].append(cost.dtn[0])\n",
    "                else:\n",
    "                    local_dict_cost['Cost'].append(cost.dtn)\n",
    "\n",
    "                if type(cost.hybrid) is np.ndarray:\n",
    "                    local_dict_cost['Cost'].append(cost.hybrid[0])\n",
    "                else:\n",
    "                    local_dict_cost['Cost'].append(cost.hybrid)\n",
    "\n",
    "                if type(cost.internet) is np.ndarray:\n",
    "                    local_dict_cost['Cost'].append(cost.internet[0])\n",
    "                else:\n",
    "                    local_dict_cost['Cost'].append(cost.internet)\n",
    "\n",
    "                local_dict_cost['Subject_ID'].extend([subject_count+1, subject_count+2, subject_count+3])\n",
    "                local_dict_cost['Network_style'].extend(['cost_dtn', 'cost_hybrid', 'cost_internet'])\n",
    "\n",
    "                if np.isnan(delivery_time.dtn_mean):\n",
    "                    local_dict_delay_mean['Delay'].append(0)\n",
    "                else:\n",
    "                    local_dict_delay_mean['Delay'].append(delivery_time.dtn_mean)\n",
    "\n",
    "                if np.isnan(delivery_time.hybrid_mean):\n",
    "                    local_dict_delay_mean['Delay'].append(0)\n",
    "                else:\n",
    "                    local_dict_delay_mean['Delay'].append(delivery_time.hybrid_mean)\n",
    "\n",
    "                if np.isnan(delivery_time.internet_mean):\n",
    "                    local_dict_delay_mean['Delay'].append(0)\n",
    "                else:\n",
    "                    local_dict_delay_mean['Delay'].append(delivery_time.internet_mean)\n",
    "\n",
    "                local_dict_delay_mean['Subject_ID'].extend([subject_count+1, subject_count+2, subject_count+3])\n",
    "                local_dict_delay_mean['Network_style'].extend(['delay_dtn', 'delay_hybrid', 'delay_internet'])\n",
    "\n",
    "                if np.isnan(delivery_time.dtn_median):\n",
    "                    local_dict_delay_median['Delay'].append(0)\n",
    "                else:\n",
    "                    local_dict_delay_median['Delay'].append(delivery_time.dtn_median)\n",
    "\n",
    "                if np.isnan(delivery_time.hybrid_median):\n",
    "                    local_dict_delay_median['Delay'].append(0)\n",
    "                else:\n",
    "                    local_dict_delay_median['Delay'].append(delivery_time.hybrid_median)\n",
    "\n",
    "                if np.isnan(delivery_time.internet_median):\n",
    "                    local_dict_delay_median['Delay'].append(0)\n",
    "                else:\n",
    "                    local_dict_delay_median['Delay'].append(delivery_time.internet_median)\n",
    "\n",
    "                local_dict_delay_median['Subject_ID'].extend([subject_count + 1, subject_count + 2, subject_count + 3])\n",
    "                local_dict_delay_median['Network_style'].extend(['delay_dtn', 'delay_hybrid', 'delay_internet'])\n",
    "\n",
    "                if np.isnan(delivery_probability.dtn):\n",
    "                    local_dict_delivery['Delivery'].append(0)\n",
    "                else:\n",
    "                    local_dict_delivery['Delivery'].append(delivery_probability.dtn)\n",
    "\n",
    "                if np.isnan(delivery_probability.hybrid):\n",
    "                    local_dict_delivery['Delivery'].append(0)\n",
    "                else:\n",
    "                    local_dict_delivery['Delivery'].append(delivery_probability.hybrid)\n",
    "\n",
    "                if np.isnan(delivery_probability.internet):\n",
    "                        local_dict_delivery['Delivery'].append(0)\n",
    "                else:\n",
    "                    local_dict_delivery['Delivery'].append(delivery_probability.internet)\n",
    "\n",
    "                local_dict_delivery['Network_style'].extend(['delivery_dtn', 'delivery_hybrid', 'delivery_internet'])\n",
    "                local_dict_delivery['Subject_ID'].extend([subject_count+1, subject_count+2, subject_count+3])\n",
    "\n",
    "                subject_count += 3\n",
    "\n",
    "            df_cost = pd.DataFrame(data=local_dict_cost)\n",
    "            df_delivery = pd.DataFrame(data=local_dict_delivery)\n",
    "            df_delay_mean = pd.DataFrame(data=local_dict_delay_mean)\n",
    "            df_delay_median = pd.DataFrame(data=local_dict_delay_median)\n",
    "\n",
    "            f_stat, p_value = stats.f_oneway(df_cost['Cost'][df_cost['Network_style'] == 'cost_dtn'],\n",
    "                                 df_cost['Cost'][df_cost['Network_style'] == 'cost_hybrid'],\n",
    "                                 df_cost['Cost'][df_cost['Network_style'] == 'cost_internet'])\n",
    "\n",
    "            local_cost.dtn.append(df_cost['Cost'][df_cost['Network_style'] == 'cost_dtn'].mean())\n",
    "            local_cost.hybrid.append(df_cost['Cost'][df_cost['Network_style'] == 'cost_hybrid'].mean())\n",
    "            local_cost.internet.append(df_cost['Cost'][df_cost['Network_style'] == 'cost_internet'].mean())\n",
    "            if p_value < significance_level:\n",
    "                local_cost.markings.append(True)\n",
    "            else: local_cost.markings.append(False)\n",
    "\n",
    "            local_cost_err.dtn.append(df_cost['Cost'][df_cost['Network_style'] == 'cost_dtn'].sem())\n",
    "            local_cost_err.hybrid.append(df_cost['Cost'][df_cost['Network_style'] == 'cost_hybrid'].sem())\n",
    "            local_cost_err.internet.append(df_cost['Cost'][df_cost['Network_style'] == 'cost_internet'].sem())\n",
    "\n",
    "            f_stat, p_value = stats.f_oneway(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_dtn'],\n",
    "                           df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_hybrid'],\n",
    "                           df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_internet'])\n",
    "\n",
    "            local_delay.dtn.append(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_dtn'].mean())\n",
    "            local_delay.hybrid.append(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_hybrid'].mean())\n",
    "            local_delay.internet.append(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_internet'].mean())\n",
    "            if p_value < significance_level:\n",
    "                local_delay.markings.append(True)\n",
    "            else:\n",
    "                local_delay.markings.append(False)\n",
    "\n",
    "            local_delay_err.dtn.append(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_dtn'].sem())\n",
    "            local_delay_err.hybrid.append(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_hybrid'].sem())\n",
    "            local_delay_err.internet.append(df_delay_mean['Delay'][df_delay_mean['Network_style'] == 'delay_internet'].sem())\n",
    "\n",
    "            f_stat, p_value = stats.f_oneway(df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_dtn'],\n",
    "                               df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_hybrid'],\n",
    "                               df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_internet'])\n",
    "\n",
    "            local_delay_median.dtn.append(df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_dtn'].median())\n",
    "            local_delay_median.hybrid.append(\n",
    "                df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_hybrid'].median())\n",
    "            local_delay_median.internet.append(\n",
    "                df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_internet'].median())\n",
    "            if p_value < significance_level:\n",
    "                local_delay_median.markings.append(True)\n",
    "            else:\n",
    "                local_delay_median.markings.append(False)\n",
    "\n",
    "            local_delay_median_err.dtn.append(df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_dtn'].sem())\n",
    "            local_delay_median_err.hybrid.append(\n",
    "                df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_hybrid'].sem())\n",
    "            local_delay_median_err.internet.append(\n",
    "                df_delay_median['Delay'][df_delay_median['Network_style'] == 'delay_internet'].sem())\n",
    "\n",
    "            f_stat, p_value = stats.f_oneway(df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_dtn'],\n",
    "                                             df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_hybrid'],\n",
    "                                             df_delivery['Delivery'][\n",
    "                                                 df_delivery['Network_style'] == 'delivery_internet'])\n",
    "\n",
    "            local_delivery.dtn.append(df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_dtn'].mean())\n",
    "            local_delivery.hybrid.append(\n",
    "                df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_hybrid'].mean())\n",
    "            local_delivery.internet.append(\n",
    "                df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_internet'].mean())\n",
    "            if p_value < significance_level:\n",
    "                local_delivery.markings.append(True)\n",
    "            else:\n",
    "                local_delivery.markings.append(False)\n",
    "\n",
    "            local_delivery_err.dtn.append(df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_dtn'].sem())\n",
    "            local_delivery_err.hybrid.append(\n",
    "                df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_hybrid'].sem())\n",
    "            local_delivery_err.internet.append(\n",
    "                df_delivery['Delivery'][df_delivery['Network_style'] == 'delivery_internet'].sem())\n",
    "\n",
    "            additional_data_dict['Satellite'].append(satellite_cost_per_day*(patient_number+1))\n",
    "    cost_return = CostGraphParams(local_cost, local_cost_err, local_cost_label, additional_data_dict)\n",
    "    delay_return = GraphParams(local_delay, local_delay_err, local_delay_label)\n",
    "    deliv_return = GraphParams(local_delivery, local_delivery_err, local_delivery_label)\n",
    "    \n",
    "    return cost_return, delay_return, deliv_return\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cost_return_patients, delay_return_patients, deliv_return_patients = run_problem_one(list(range(2, 11, 2)), [0.3], VariedParameter.patients)\n",
    "cost_return_ratio, delay_return_ratio, deliv_return_ratio = run_problem_one([10], [0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1.], VariedParameter.ratio)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XucVWXZ//HP1wEFBdFAK06CAqaiYoCKmoyVh4hRn9SKzEMekEzMUiuTn46lySOUT2U9OZqShzREnxLT0kxQ0xTGUElSjDQnKA7KySBBrt8faw3uGeawmZk9e7Hn+3699mtmr+O17r33uvZ9r3vfSxGBmZlZ1mxX7ADMzMwa4gRlZmaZ5ARlZmaZ5ARlZmaZ5ARlZmaZ5ARlZmaZ5AS1jZB0taTlkv6ZPv8vSW9IWivpoCLGlYk4cuKZJemcIu27q6SZklZJuqfA++qflnlZIfdjDZP0mqSPFzuOUucElRHpG35detKpfdyQzusHXAzsGxEfSFeZClwQEd0i4k+t2G9IGtSK0JuMI93+i5K2y5l2taRprdhnVp0MvB/oGRGn1J8pqVLShvS1XSnpKUmj8tlw/RNiRPw9LfN3Wxt0MZN6vTha9V7JynHUp8SFkuZLeltSjaR7JO3fyu229rObeU5Q2VKRnnRqHxek0/cAVkTE0pxl9wD+3P4hbiGfOHoDn22HWNpMelLZ2s/HHsArEbGxiWV+ERHdgN2AJ4H7JKmlcZagTL9XJHVqwWrfB74MXAi8DxgC/BL4ZBuGVpoiwo8MPIDXgI83MP3jwDpgE7AWuCv9G8DbwF/T5XoD9wLLgL8BF+Zsowz4JvBXYA1QDfQDHs/ZzlrgMw3sfztgEvA6sBS4DegB7NBQHA2sH8DXgYVAp3Ta1cC09P9yoKaxsgAqgXuAO9LYXyT5gF+WxvMGcEzOurOAa4FngVXAr4D35cw/FHgKWAk8D5TXW/ca4A9pmQ9q4Hj2SZdbSZKYj0+nXwW8A2xIy+XsBtatBO7Ieb5fWj69gL2A3wMrgOXAncAu6XK3p6//unTbXwMGpOvWlmkP4KfAEuAfaRmXpfPOJEmGU4G30vfHJ9J51wDvAuvTbd8ACLg+Ld9VwAvA0EZe397A/cCbwKvAufWOdzrJe2ZNWl4jmvgMNPleaer1a+Q4rgJ+mM7vTPI+vS593jVddtf0+fFpfCvT13efeu/Hr6fl8B+gE3Xfox9Ky/SzDRzT4DSug5s47h5pGS0j+ZxNArZL5w0CZqevw3KSLziQx2e3FB5FD8CP9IVoJEGl88rZ8iQepCdQkiRSDVwBbA/sCSwCjk3nX0pyYt87PfkcSNIMVWc7jez7rPTEsyfQDbgPuL2hOBpZP9IPaTVwTjptaxPUeuDY9MRwW3oyuDw96ZwL/C1n3VkkJ+ihwE4kSfuOdF4fkgQwJi2zo9Pnu+Ws+3eSxNEJ6Fwvrs5pWXwzLeePkpx4986J9Y4myqIyJ5YdgCnAG+nzQWk8O5DUrh4H/qex9wdbJqhfAjemx7w7SYI+L513JkniPJfky8oXgcWAco77nJxtH5u+Xruk75d9gA82ckyzgR8DXYBhJCfZj9V77cak+70W+GMr3iv5vH65x/FR4MX0/8NIvqA9kzPv+fT/ISQn+qPT1/hr6eu8fU7ZzyP5Utc19/UAPkzynhnbyDFNAF5v5rN/G8kXqe7p6/oK6Rccki+kl6fH2wU4It/PXik83MSXLb9Mr03UPs7Nc72RJB/Sb0XEOxGxCLiJ95pKzgEmRcTLkXg+Ilbkue1Tge9FxKKIWEtSc/nsVjZ1BPD/gCsk7bAV69V6IiJ+G0nT2T0kJ/DJEbEBuBsYIGmXnOVvj4j5EfF2ut9Pp50JPg88GBEPRsSmiHgEmEtywqs1LSL+HBEb0+3nOpQkSU9Oy/n3wAPAuK04lk9LWklS8xsOnAgQEa9GxCMR8Z+IWAZ8DxidzwYlvR/4BHBRRLwdSVPw9dRtKns9Im6K5JrVz4APklwva8gGkpPlh0iS2IKIWNLAfvsBRwBfj4j1ETEPuBk4LWexJ9PyfpekJnhgM4fT1Hsln9cv19PAYEk9gSNJaph9JHUjKdvZ6XKfAX6dlv8GkppmV5KkVusHEfFGRKzLmfYRktrjGRHxQCMx9CSp1TYofV9+BrgsItZExGvAd3mvDDeQNB33Tsv4yca2VYqcoLLlxIjYJedxU57r7QH0zk1uJN/ya09A/Ui+PbZEb5Jmh1qvk9QuGju5NSgiHiT5pjm+BTH8K+f/dcDyeK9zQO0Jo1vOMm/k/P86ybfiXiTldEq9cjqC5GTd0Lr19Sap8Wyqt/0+eR8JTE9f290j4qMRUQ0gaXdJd0v6h6TVJE2avfLc5h4kx7gk57huJKlJ1fpn7T8R8e/039wyI2f+70mayH4E/EtSlaSdG1i0N/BmRKzJmVa/PP6Z8/+/gS7Nfblp4r2Sz+uXu511JAlsNEmCmk3SPHg4dRNUnfd4+vq+Ue84GnpfTACeiojHmjicFY3Fl+pFUhuv/xmr3ffXSGqxz0r6s6SzmthWyXGCKg1vkDRz5Sa37hExJmf+Xi3c9mKSE0Ot/sBG6iaNfE0iaa7YMWfa27nP02+Uu7Vg27n65fzfn+Rb6HKScri9XjntFBGTc5Zvanj/xUC/ep0n+pM0KbbWtem+D4iInUlqC7mdJ5qK6w2SayO9co5r54jYL899b7HtiPhBRAwnae4cQtJMXN9i4H2SuudMa6vyaOi90tzr11AZzSZpzjsImJM+PxY4mKQZtfY4Nr/H004r/eodR0PbngD0l3R9E8fxKNBX0ohG5i/nvVpSrc1lGBH/jIhzI6I3cB7w41LvuZfLCao0PAuslvT19Lc4ZZKGShqZzr8Z+LakwWnvtAPSZg9IEs2eTWz7LuArkgamTSPfIblQ21RPtQZFxCySa2Fn5Ex+heRb9ScldSY5MbWkGTDX5yXtK2lH4FvAjLTGdQdQIenYtIy6SCqX1DfP7T5DklC/JqmzpHKggqSZsbW6k1zsXimpD1smhEZfp7T57WHgu5J2lrSdpL0k5dVEWH/bkkZKOiR9Pd4muY60RXf2iHiDpEZybVqWBwBnk3TwaJVG3ivNvX4NldFs4HTgpYh4h/Q6FckXumXpMtOBT0r6WHrMF5Mk/KeaCXMNcBxwpKTJDS0QEQtJrtHdlca6fRr3ZyV9I31fTgeukdRd0h7AV9NjRdIpOcf3FkmirH0tmvvsbvOcoLJlpur+Dur/8lkpfZNXkFyk/hvJt7KbSXoHQXI9YzrJSWw1SVt813ReJfCztMnk0w1s/haSawePp9teD0xswbHVmkTS1bY29lXA+Wm8/yA5Ida0YvuQxDuNpHmpC0n33toT6gkkzZ/LSL6RX0qen4P0BHc8yfWe5SQnntMj4i+tjBeSHmcfJumt9WuSzii5rgUmpa/TJQ2sfzpJU9FLJCeyGTTdtJTr+8DJkt6S9ANgZ5JrmG+RNDetILku05BxJBf2FwP/B1yZXhtqC/XfK829fvWPA5Ik05X3aksvkbyHH8/Z7sskNdYfkryuFSQ/+XinuQAjYiVJ54pPSPp2I4tdyHtNpitJmtv/C5iZzp9I8r5fRNLb8ucknztIri8/I2ktyfWuL0fE39J5lTT92d3m1fbiMTMzyxTXoMzMLJOcoMzMLJOcoMzMLJOcoMzMLJNaMvBh5vXq1SsGDBhQ7DDMzKwB1dXVyyOi2d87lmSCGjBgAHPnzi12GGZm1gBJrze/lJv4zMwso5ygzMwsk5ygzMwsk0ryGpSZWSFs2LCBmpoa1q9fX+xQtgldunShb9++dO7cuUXrO0GZmeWppqaG7t27M2DAAJJBz60xEcGKFSuoqalh4MCBLdpGSTXxSaqQVLVq1apih2JmJWj9+vX07NnTySkPkujZs2erapsllaAiYmZEjO/Ro0fzC5uZtYCTU/5aW1YllaDMzKx0+BqUmVkLVVW17fbG17/JfQPKysrYf//92bBhA506deKMM87goosu4pFHHuHrX/86AK+++ip9+vSha9euHHDAAZx11lkcddRR3H///VRUVAAwduxYzvnylzl89Gj++de/8p+332523zvstBMf2Gsvdtt++1YdZ76coMzMtiFdu3Zl3rx5ACxdupTPfe5zrFq1iquuuopjjz0WgPLycqZOncqIEcmd5mfNmkXfvn255pprNieoXB/Ya6/2O4Ct4CY+M7Nt1O67705VVRU33HADzd189sADD6RHjx488khb3fC48JygzMy2YXvuuSebNm1i6dKlzS47adIkrr766naIqm04QZmZbeOaqz3V+shHPgLAE088Uchw2owTlJnZNmzRokWUlZWx++6757X85ZdfzjXXXFPgqNqGE5SZ2TZq2bJlTJgwgQsuuCDv3xwdc8wxvPXWWzz//PMFjq713IvPzKyF8ukW3tbWrVvHsGHDNnczP+200/jqV7+6Vdu4/PLLOeGEEwoUYdtxgjKzDqNq8WKmnnQSC//4x2aXHXzooVxy772M7927HSLL37vvvtvsMrNmzarzvLy8nPLy8s3Pjz/+eCKCZe+808bRtS0nKDPrUC65995ih2B58jUoMzPLJCcoMzPLJCcoMzPLJCcoMzPLJCcoMzPLJPfiMzNroarqtr3fxvjhzf+wqlu3bqxdu3bz82nTpjF37lxuuOGGRtepP7p5Y+ZVVzP9jjv4zvXXbzFv+JAhPPzUU/Ts1avZGNuKE5SZmbFx40aGDR/OsOHDix3KZm7iMzMrAWvWrGHgwIFs2LABgNWrVzNgwIDNz++44w4OO+wwhg4dyrPPPgvAdd/+Nhd/8YucMmYMF5x1Fn+YPZtTTzwRgDdXrOCUMWP46MEHc/H55+c9IG1bcoIyK1FVixdTtXgxQ0aNQlKzjyGjRlG1eHGxw7Zm1A51VPu44oorAOjevTvl5eX8+te/BuDuu+/mpJNOonPnzgC8/fbbPPXUU/z4xz/mrLPO2ry95//0J267915+ctttdfYz9eqrOeTww/n9s89y3Nix1Pz97+10hO9xE59ZifPICaUl94668N41KIBzzjmH6667jhNPPJFbb72Vm266afNy48aNA+DII49k9erVrFy5EoBjx46la9euW+zn6Sef5NZf/AKAo8eMYZdddy3YMTXGNSgzsxJx+OGH89prrzF79mzeffddhg4dunle/dHOa5/vuOOOjW4v3xHSCyXzCUrSnpJ+KmlGsWMxM8u6008/nXHjxvGFL3yhzvRfpLWhJ598kh49etCjR48mtzPqiCO49+67AXj0N79h5VtvFSbgJhSliU/SLcBYYGlEDM2ZfhzwfaAMuDkiJkfEIuBsJygzy5p8uoW3t1NPPZVJkyZtbtKrteuuu3LYYYexevVqbrnllma3c8mkSZx32ml87Je/5LCPfIS+/fsXKuRGqRg9MyQdCawFbqtNUJLKgFeAo4EaYA4wLiJeSufPiIiT89n+iBEjorZN1qyjammHh6zdXqIttaRMcstjwYIF7LPPPm0ZUpubMWMGv/rVr7j99tubXbalt9vYbfvt8162oTKTVB0RTf8oiyLVoCLicUkD6k0+GHg1rTEh6W7gBOCl9o3OzGzbNHHiRB566CEefPDBYofSJrLUi68P8EbO8xrgEEk9gWuAgyRdFhHXNrSypPHAeID+RaiKmpkV2w9/+MNih9CmspSgGuouEhGxApjQ3MoRUQVUQdLE18axmZlZO8tSL74aoF/O876AfzVoZtZBZSlBzQEGSxooaXvgs8D9RY7JzMyKpCgJStJdwNPA3pJqJJ0dERuBC4DfAguA6RHx563cboWkqlWrVrV90GZm1q6K1YtvXCPTHwRa3P0kImYCM0eMGHFuS7dhZpa3qra93Qbjm/9d1WuvvcbYsWOZP3/+5mmVlZV069aN+fPnM3v2bHr06MF2223Hj370I0aNGsWZZ57JI488wqJFi9hhhx1Yvnw5I0aMYM4rr7Rt/G0sS018ZmbWSlOmTGHevHlMnjyZ8847b/P0srKyvH6gmyVOUFYyPHK32XuOPPJIXn311c3PL7roIq6//no2btxYxKi2Tpa6mZu1mkfuNkvMnDmT/ffff/Pz/v37c8QRR3D77bdTUVFRxMjyV1I1KHeSMLNS19gI47XTL730UoYNG0ZVVRU//elP6yzzzW9+kylTprBp06aCx9kWSqoG5U4SZlbqevbsyVv1RhZ/8803GThwIJBcgzr55IaHLR00aBDDhg1j+vTpBY+zLZRUDcrMrNR169aND37wgzz66KNAkpx+85vfcMQRR+S1/uWXX87UqVMLGWKbKakalJlZu8qjW3gh3HbbbXzpS1/i4osvBuDKK69kr732ymvd/fbbjw9/+MM899xzhQyxTThBmZltY/bdd18ee+yxLaZPmzatweXrT7/vvvuAlt9uo72UVBOfO0mYmZWOkkpQETEzIsY3dytjMzPLvpJKUGZmVjqcoMzMLJOcoMzMLJOcoMzMLJNKqpu5pAqgYtCgQcUOxcw6gLYecHh87955LXfNNdfw85//nLKyMrbbbjtuvPFGDjnkkAaXnTZtGscccwy9m9n2xHPO4ZgxY6j41Kc48eijqZw8mWHDhzPu+OP5yW23AXDv3Xdz1oQJW3dQrVBSNSj34jOzUvf000/zwAMP8Nxzz/HCCy/wu9/9jn79+jW6/LRp01jcikR61/3302OXXVi1ciXTbryxxdtpiZJKUGZmpW7JkiX06tWLHXbYAYBevXrRu3dvvvWtbzFy5EiGDh3K+PHjiQhmzJjB3LlzOfXUUxk2bBjr1q2jurqa0aNHM3z4cD79yU/yryVLmtzf8CFDWLF8OVdPmsRrixZx1MiRXHrppUAy7t/IkSM54IADuPLKK9v8WJ2gzMy2IccccwxvvPEGQ4YM4fzzz2f27NkAXHDBBcyZM4f58+ezbt06HnjgAU4++WRGjBjBnXfeybx58+jUqRMTJ05kxowZVFdX87kzz+Q7eSaWSVdfzYA99+SxOXOYMmUKDz/8MAsXLuTZZ59l3rx5VFdX8/jjj7fpsZbUNSgzs1LXrVs3qqureeKJJ3jsscf4zGc+w+TJk+nevTvXXXcd//73v3nzzTfZb7/9trjv08svv8z8+fM5+uijAXhn40Z2/8AHWhTHww8/zMMPP8xBBx0EwNq1a1m4cCFHHnlk6w4whxOUmdk2pqysjPLycsrLy9l///258cYbeeGFF5g7dy79+vWjsrKS9evXb7FeRLDffvvx9NNPA60biy8iuOyyy+rcVr6tuYnPzGwb8vLLL7Nw4cLNz+fNm8fee+8NJNej1q5dy4wZMzbP7969O2vWrAFg7733ZtmyZZsT1IYNG/jLSy/ltd9u3buzdu3azc+PPfZYbrnlls3T/vGPf7B06dLWHVw9JVWD6kjdzGu7t0496SQW/vGPzS4/+NBDueTee/PuxmpmzSvG52nt2rVMnDiRlStX0qlTJwYNGkRVVRW77LIL+++/PwMGDGDkyJGblz/zzDOZMGECXbt25emnn2bGjBlceOGFrFq1iv9s2MD4iRP50L77Nrvf9/XsycGjRnHkQQcxdswYpkyZwoIFCxg1ahSQND3ecccd7L777m12rIqINttYVowYMSLmzp1b7DAKqqW/vyjlBNWSMnF5bMllUldueSxYsIB99tmnLUMqqpY28e22/fZ5L9tQmUmqjogRza3rJj4zM8skJygzM8skJygzs61QipdFCqW1ZeUEZWaWpy5durBixQonqTxEBCtWrKBLly4t3kZJ9eIzMyukvn37UlNTw7Jly4odSptY8+67LVpveVlZXst16dKFvn37tmgf4ARlZpa3zp07M3DgwGKH0Way3tPTTXxmZpZJJZWgJFVIqlq1alWxQzEzs1YqqQTl+0GZmZWOkkpQZmZWOpygzMwsk5ygzMwsk5ygzMwsk5ygzMwsk5ygzMwsk5ygzMwsk5ygzMwsk5ygzMwsk5ygzMwsk0oqQXksPjOz0lFSCcpj8ZmZlY6SSlBmZlY6mk1Qkk7JZ5qZmVlbyqcGdVme08zMzNpMo7d8l/QJYAzQR9IPcmbtDGwsdGBmZtaxNZqggMXAXOB4oDpn+hrgK4UMyszMrNEEFRHPA89L+nlEbACQtCvQLyLeaq8AzcysY8rnGtQjknaW9D7geeBWSd8rcFxmZtbB5ZOgekTEauBTwK0RMRz4eGHDMjOzji6fBNVJ0geBTwMPFDgeMzMzIL8E9S3gt8BfI2KOpD2BhYUNy8zMOrqmevEBEBH3APfkPF8EnFTIoMzMzPIZSaKvpP+TtFTSvyTdK6lvewRnZmYdVz5NfLcC9wO9gT7AzHSamZlZweSToHaLiFsjYmP6mAbsVuC4zMysg8snQS2X9HlJZenj88CKQgfWEr4flJlZ6cgnQZ1F0sX8n8AS4OR0Wub4flBmZqUjn158fycZj8/MzKzdNFqDknSdpAkNTP+KpP8ubFhmZtbRNdXENxaoamD694FPFiYcMzOrrKxEUrOPysrKYodaUE0lqIiITQ1M3ASocCGZWUdRVV1FVXUVQ4YPyeuEPGT4EKqqG/reXDqqqquoXlzd/IJA9eLqki6Ppq5B/VvS4IioM6yRpMHAusKGZaWg9oMzdfxUFj7X/OhYgz88mEuqLmH88PGFDq1oWlImr1S/Uuiwiu6SqkuKHUKmVJxXQcV5FcUOo+iaSlBXAA9Jupr3blg4guR27xcVOrBtUYtOPuclH8zyqVOZvbD5dUYPHsysSy6BsWNbF2w72uqTT1VSji6TVAcoj63mMqmrRMujqRsWPiTpROBSYGI6eT5wUkS82B7Bbau26uSTpv5Zl/gbZH0uk7pcHltymdRVauXRZDfziJgPnNFOsZiZmW2Wzw91zczM2p0TlJmZZVI+t9t4X3sEYmZmliufGtQzku6RNEaSf/9kZmbtIp8ENYRkRInTgFclfUfSkMKGZWZmHV2zCSoSj0TEOOAckl59z0qaLWlUwSM0M7MOqdnRzCX1BD5PUoP6F8lvou4HhgH3AAMLGaCZmXVMzSYo4GngduDEiKjJmT5X0k8KE5aZmXV0+SSovSMiGpoREb7thpmZFUSjCUrSTCDS/7eYHxG+iaGZmRVMUzWoqe0WhZmZWT1NDRY7uz0DMTMzy9VUE9/0iPi0pBdJm/pyRcQBBY3MzMw6tKaa+L6c/s32DUPMzKwkNdXEtyT9+3r7hWNmZpbIZ7DYQyXNkbRW0juS3pW0uj2CS/e/k6SfSbpJ0qnttV8zMyuufMbiuwEYBywEupIMd/TD1uxU0i2SlkqaX2/6cZJelvSqpG+kkz8FzIiIcwF3bTcz6yDyuh9URLwKlEXEuxFxK3BUK/c7DTgud4KkMuBHwCeAfYFxkvYF+gJvpIu928r9mpnZNiKfkST+LWl7YJ6k64AlwE6t2WlEPC5pQL3JBwOvRsQiAEl3AycANSRJah5NJFRJ44HxAP37929NeGZmlgH51KBOS5e7AHgb6AecVIBY+vBeTQmSxNQHuA84SdL/AjMbWzkiqiJiRESM2G233QoQnpmZtadma1AR8bqk3dL/rypgLA3dDDEi4m3gCwXcr5mZZVBTTWaSVClpOfAX4BVJyyRdUaBYakhqZ7X6AosLtC8zM8u4ppr4LgIOB0ZGRM+I2BU4BDhc0lcKEMscYLCkgek1r8+S3Hcqb5IqJFWtWrWqAOGZmVl7aipBnQ6Mi4i/1U5IOzB8Pp3XYpLuIrnP1N6SaiSdHREbSa5z/RZYAEyPiD9vzXYjYmZEjO/Ro0drwjMzswxo6hpU54hYXn9iRCyT1Lk1O01vH9/Q9AeBB1uzbTMzKw1N1aDeaeE8MzOzVmuqBnVgI0MaCehSoHjMzMyApgeLLWvPQNqCpAqgYtCgQcUOxczMWimvoY62Fe4kYWZWOkoqQZmZWelwgjIzs0xygjIzs0wqqQTlkSTMzEpHSSUod5IwMysdJZWgzMysdDhBmZlZJjlBmZkVUGVlJZKafVRWVhY71MzJ55bvZmbWQpWVlXWST3l5OQCzZs0qSjzbkpKqQbkXn5lZ6SipGlREzARmjhgx4txix2JmHVtVVcPTlyxpej7DCxLONqmkalBmZlY6nKDMzCyTSqqJz8wsa2bOrOSBB67aYvp556nO87Fjr6SiorKdoto2OEGZmRVQRUWlE08LuYnPzMwyyQnKzMwyqaQSlH8HZVZcHjXB2lJJJSiPZm5WXJWVlUTE5sfo0aMZPXp0nWkR4QRleXEnCTNrNf8o1QqhpGpQZmZWOpygzMwsk9zEZ2Ztxj9KtbbkBGVmbcY/SrW25CY+MzPLJCcoMzPLpJJKUP6hrplZ6SipBOUf6pqZlY6SSlBmZlY6nKDMzCyTnKDMzCyTnKDMzCyTnKDMzCyTnKDMWsH3PzIrHA91ZNYKlZWVdZJPeXk5ALNmzSpKPGalxDUoMzPLJNegzFrAN+gzK7ySqkF5qCMzs9JRUgnKQx2ZmZUON/GZtYJv0GdWOE5QZq3gG/SZFU5JNfGZmVnpcIIyM7NMcoKyvHnUBDNrT74GZXnzqAlm1p5cgzIzs0xyDcry0tDICB41wcwKyTUoMzPLJCcoMzPLJCcoMzPLJF+Dsrx5WB8za09OUJY3D+tjZu3JTXxmZpZJJZWgfD8oM7PSUVIJyveDMjMrHSWVoMzMrHQ4QZmZWSY5QZmZWSY5QZmZWSY5QZmZWSY5QZmZWSY5QZmZWSY5QZmZWSY5QTWhsrISSc0+cm+DbmZmbcODxTahsrKyTvIpLy8HYNasWUWJx8ysI3ENyszMMskJyszMMslNfA2oqmp4+pIlTc9neEHCMTPrkFyDMjOzTHKCMjOzTHKCMjOzTHKCMjOzTHIniSbMnFnJAw9ctcX0885Tnedjx15JRUVlO0VlZtYxOEE1oaKi0onHzKxI3MRnZmaZ5ARlZmaZ5ARlZmaZ5ARlZmaZlPkEJWlPST+VNKPYsZiZWfspaIKSdIukpZLm15t+nKSXJb0q6RtNbSMiFkXE2YWM08zMsqfQ3cynATcAt9VOkFQG/Ag4GqgB5ki6HygDrq23/lkRsbTAMZqZWQYVNEFFxOMCwWXsAAAHHklEQVSSBtSbfDDwakQsApB0N3BCRFwLjG3pviSNB8YD9O/fv6WbMTOzjFBEFHYHSYJ6ICKGps9PBo6LiHPS56cBh0TEBY2s3xO4hqTGdXOayJrb5zLg9TY5gLbTC1he7CAyxOWxJZdJXS6PukqpPPaIiN2aW6gYI0mogWmNZsmIWAFM2Jod5HPg7U3S3IgYUew4ssLlsSWXSV0uj7o6YnkUoxdfDdAv53lfYHER4jAzswwrRoKaAwyWNFDS9sBngfuLEIeZmWVYobuZ3wU8DewtqUbS2RGxEbgA+C2wAJgeEX8uZBwZ0diN4jsql8eWXCZ1uTzq6nDlUfBOEmZmZi2R+ZEkzMysY3KCMjOzTHKCKiBJ/SQ9JmmBpD9L+nKxY8oCSWWS/iTpgWLHkgWSdpE0Q9Jf0vfKqGLHVEySvpJ+XuZLuktSl2LH1N4aGiZO0vskPSJpYfp312LG2B6coAprI3BxROwDHAp8SdK+RY4pC75M0kHGEt8HfhMRHwIOpAOXjaQ+wIXAiPTH/WUkPX07mmnAcfWmfQN4NCIGA4+mz0uaE1QBRcSSiHgu/X8NyYmnT3GjKi5JfYFPAjcXO5YskLQzcCTwU4CIeCciVhY3qqLrBHSV1AnYkQ74O8mIeBx4s97kE4Cfpf//DDixXYMqAieodpIO+XQQ8ExxIym6/wG+BmwqdiAZsSewDLg1bfa8WdJOxQ6qWCLiH8BU4O/AEmBVRDxc3Kgy4/0RsQSSL7/A7kWOp+CcoNqBpG7AvcBFEbG62PEUi6SxwNKIqC52LBnSCfgw8L8RcRDwNh2g6aYx6XWVE4CBQG9gJ0mfL25UVixOUAUmqTNJcrozIu4rdjxFdjhwvKTXgLuBj0q6o7ghFV0NUBMRtTXrGSQJq6P6OPC3iFgWERuA+4DDihxTVvxL0gcB0r8lfysiJ6gCkiSSawsLIuJ7xY6n2CLisojoGxEDSC58/z4iOvS344j4J/CGpL3TSR8DXipiSMX2d+BQSTumn5+P0YE7jdRzP3BG+v8ZwK+KGEu7KMZo5h3J4cBpwIuS5qXTvhkRDxYxJsueicCd6diUi4AvFDmeoomIZyTNAJ4j6QX7JzriED/JMHHlQC9JNcCVwGRguqSzSRL5KcWLsH14qCMzM8skN/GZmVkmOUGZmVkmOUGZmVkmOUGZmVkmOUGZmVkmOUFZhyApJH035/klkirbaNvTJJ3cFttqZj+npKOdP1Zv+gBJ6yTNk/SSpJ9IavSznY6efn7O895p1+6WxnWRpB1bur5ZY5ygrKP4D/ApSb2KHUguSWVbsfjZwPkRcVQD8/4aEcOAA4B9aXog0V2AzQkqIhZHRGsS7EUkg7qatSknKOsoNpL84PMr9WfUrwFJWpv+LZc0W9J0Sa9ImizpVEnPSnpR0l45m/m4pCfS5cam65dJmiJpjqQXJJ2Xs93HJP0ceLGBeMal258v6b/TaVcARwA/kTSlsYOMiI3AU8AgSd0kPSrpuXR7J6SLTQb2SmtcU9Ia2Pw8Yp6Vc9+qO5W4kGTMvMfSYypLy3N+us8tytssXx5JwjqSHwEvSLpuK9Y5ENiH5NYHi4CbI+JgJTefnEhSewAYAIwG9iI5WQ8CTicZjXukpB2AP0iqHZn7YGBoRPwtd2eSegP/DQwH3gIelnRiRHxL0keBSyJibmPBpk1tHwOuANYD/xURq9Oa4x8l3U8yGO3QtMZVO9J+rbObiPkgYD+S21/8ATg8In4g6avAURGxXNJwoE96Lyck7dJ8EZs1zDUo6zDSkeRvI7khXr7mpPf1+g/wV6D2ZP0iSVKqNT0iNkXEQpJE9iHgGOD0dJirZ4CewOB0+WfrJ6fUSGBWOljqRuBOkvtFNWevdD9/AH4dEQ8BAr4j6QXgdyT3Int/M9tpLuaaiNgEzKt3/LUWAXtK+qGk44AOO3q/tZ5rUNbR/A/JOG+35kzbSPplLR2gdPucef/J+X9TzvNN1P381B8zLEgSxMSI+G3uDEnlJLfVaIiaPYKG1V6DynUqsBswPCI2pKPIN3f79KZizi2Ld2ng/BERb0k6EDgW+BLwaeCsrTgOs81cg7IOJSLeBKaTNGXVeo2kSQ2SexF1bsGmT5G0XXpdak/gZeC3wBeV3HIFSUPU/M0InwFGS+qVdqAYB8xuQTwAPUjuv7VB0lHAHun0NUD3RtZpScybt5c2JW4XEfcC/4+OfesQayXXoKwj+i5wQc7zm4BfSXoWeJTGazdNeZkkkbwfmBAR6yXdTNIM9lxaM1tGM7fpjoglki4DHiOpzTwYES29rcKdwExJc0ma5P6S7mOFpD+kHSMeIrk2V2urYybpfPKQpCUk1+RuzenmflkLYzfzaOZmZpZNbuIzM7NMcoIyM7NMcoIyM7NMcoIyM7NMcoIyM7NMcoIyM7NMcoIyM7NM+v8q5VYXMhD5GQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "label = cost_return_patients.local_cost_label\n",
    "label.y_label = 'Daily Cost'\n",
    "plot_plots(cost_return_patients.local_cost, cost_return_patients.local_cost_err, label, additional_data=cost_return_patients.additional_data_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "delay_return_patients.local_label.y_label = 'Delivery Latency'\n",
    "plot_plots(delay_return_patients.local, delay_return_patients.local_err, delay_return_patients.local_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_plots(deliv_return_patients.local, deliv_return_patients.local_err, deliv_return_patients.local_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8216666666666677\n",
      "4.179539758487127\n",
      "[0.875, 0.9175, 0.9616666666666666, 0.96625, 0.9470000000000003]\n",
      "[0.875, 0.9175, 0.9616666666666666, 0.96625, 0.9470000000000003]\n",
      "=========================\n",
      "2.0710000000000015\n",
      "17.663866262953658\n",
      "=========================\n",
      "-132.71066527855336\n",
      "-3.2781124028280515\n",
      "148.21705642603905\n"
     ]
    }
   ],
   "source": [
    "print((np.mean(deliv_return_patients.local.hybrid)-np.mean(deliv_return_patients.local.dtn))*100)\n",
    "print((np.mean(deliv_return_patients.local.hybrid)-np.mean(deliv_return_patients.local.dtn))*200/(np.mean(deliv_return_patients.local.hybrid)+np.mean(deliv_return_patients.local.dtn)))\n",
    "print(deliv_return_patients.local.hybrid)\n",
    "print(deliv_return_patients.local.hybrid)\n",
    "print('=========================')\n",
    "print((np.mean(delay_return_patients.local.dtn)-np.mean(delay_return_patients.local.hybrid)))\n",
    "print((np.mean(delay_return_patients.local.dtn)-np.mean(delay_return_patients.local.hybrid))*200/(np.mean(delay_return_patients.local.dtn)+np.mean(delay_return_patients.local.hybrid)))\n",
    "print('=========================')\n",
    "print((np.mean(cost_return_patients.local_cost.dtn)-np.mean(cost_return_patients.local_cost.hybrid))*200/(np.mean(cost_return_patients.local_cost.dtn)+np.mean(cost_return_patients.local_cost.hybrid)))\n",
    "print((np.mean(cost_return_patients.local_cost.internet)-np.mean(cost_return_patients.local_cost.hybrid))*200/(np.mean(cost_return_patients.local_cost.internet)+np.mean(cost_return_patients.local_cost.hybrid)))\n",
    "print((np.mean(cost_return_patients.additional_data_dict['Satellite'])-np.mean(cost_return_patients.local_cost.hybrid))*200/(np.mean(cost_return_patients.additional_data_dict['Satellite'])+np.mean(cost_return_patients.local_cost.hybrid)))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XucHFWd9/HPlwRJJCFgAkgSQgKCa0AMZMRHRBIvIGgmuI+sgBeIXBJdQBFwcSULAy4rD+CyKrgyIEaQq66XZA1CBMJF5JJAuEuMMZAYhBDuCJKE3/NHnQ6VTs9MTzI1XTPzfb9e/ZquqtNVv6qu6V+fU6dPKSIwMzMrm00aHYCZmVktTlBmZlZKTlBmZlZKTlBmZlZKTlBmZlZKTlBmZlZKTlA9lKR/l/SMpL+m6X+UtFTSy5L2aGBcpYgjT9IUSbdvxOuvk3REV8ZUBEmj0nHv1+hYNoakiZKW5aYfljSxgSFZgzhBlZSkJZJeTR84lccFadn2wEnA2Ih4e3rJecBxETEoIu7biO2GpHdsROjtxpHW/0ran79I+s8yfaBKapH0k/y8iDgwIn5cwLZmSHo9HYtnJc2R9A+deP0SSR/NxflEOu5rujrWzsiduy9Jel7SHZK+KGmDPm8iYteImNvFYXbaxpy71UnX6uMEVW7N6QOn8jguzd8BWBkRT+fK7gA83P0hrqeeON4TEYOAjwCfAY4pPKryOicdixHAX4AfNjiertIcEYPJzoezgVMo0b5J6r+BL62cuxOAQ4Ajuy4qq+YE1cOkb8xzgOHpm9xVkl4G+gH3S/pTKjdc0v9IWiHpz5K+nFtHP0nfkPSn9C13vqTtJd2aityf1n1Ije1vImm6pMclPS3pMklDJG1WK472RMQfgNuA3dK63yVpbvrW/bCkybntzpD0g1TLeEnSLZJ2SMtGp2+3/XPl50o6uo1j+J3UDPli2vcPpvkHAN8ADkn7f3/1utra/6o4jpD0hLIm2FM7Og7pWLwKXAuMy8W5k6SbJK1M67pC0pZp2eXAKGBWivVfqo9DOgdmptrZIkltfhFI7+Fl6Xx5PO3jJmnZFEm3SzpP0nPpfDqwzv16ISJmkn2YHyGp8l5vltb3hKSn0ns7sI3Ylkj6aNqfVyW9Lbdsj3RsNk3TR0p6NMV5feUcSctC0rGS/gj8UdKFkr5dta1Zkk6oY78WAb9j3ffrC2nbL0laLGlamr85cB1v/s++nPZlE0lfT/+HKyVdm983AyLCjxI+gCXAR9tYNhFYVjUvgHek55sA84HTgLcAOwKLgY+l5V8DHgTeCQh4DzC0ej1tbPtIYFFa5yDg58DlteJo4/X5OMcCfwWOAjZN6/1GivnDwEvAO1PZGWl6X2Az4DvA7WnZ6LTe/rntzAWOTs+nVMqm6c8BQ4H+ZE2lfwUGpGUtwE+qYs6vq839z8VxMTAwHde/A+9q41jMAP49Pd8cuBy4P7f8HcB+aX+3Bm4F/qutc6T6OAC3AN8HBpB9kK4APtJGLJcBvwIGp/UsBI7KHb9VZDXdfsCXgOWAOnPuAk8AX0rP/wuYCbwtbXMW8K1a53d+fcBNwDG5ZecCP0jPP5nem3el93Y6cEfVuTcnbXMgsFfaj03S8mHA34Bt6zh3/wF4EvhqbvkngJ3I/qcmpHXt2c7/7AnAncDI9B5fBFzV6M+eMj0aHoAfbbwx2T/ly8DzuccxaVmtkz3/z/M+4Imq5f8K/Cg9fww4qI3tdpRgbgT+OTf9zvTh1b/O1wfwIvAc8Cfg38kS6gfJEsUmubJXAS3p+Qzg6tyyQcAaYHs6maBqxPQcWdMNdJyg2tz/XBwjc8vvBg5tY7szgNfSe/sG8Gdg93bi/CRwX9U5UjNBpeOyBhicW/4tYEaN9fYjS6Rjc/OmAXNzx29Rbtlb03be3s65WytB3QmcSvYB/gqwU27Z+4E/1zq/WTdBHQ3clJ4LWArsm6avIyXVNL0JWZLYIXfufbgqpkeB/dLz44DZdZy7r6TnVwGbtVP+l8BX2vmffZTcFwZgO3L/S36Em/hK7pMRsWXucXGdr9uBrDnh+cqDrGaybVq+PVly2BDDgcdz04+TfSBuW7t4TXtGxFYRsVNETI+IN9J6l6bn+XWPyE0vrTyJiJeBZ9PrOkXSSakp5oV0bIaQfXuuRz37/9fc87+RJdO2nBcRW5Ill1fJEl4lzm0kXa3sgvyLwE86GeezEfFSVawjapQdRlZrrd6vfNm1+xQRf0tP29uvWkaQvWdbkyW5+bnz8zdpfkd+Brxf0nCy2nSQNRNDdt5/J7fOZ8mSWM1zKPkxWY2a9PfyDra/J9l+H0L2RXDzygJJB0q6MzWpPg98nPbfrx2AX+TifZTsS0Vn/pd6NSeo3mkp2bfRfHIbHBEfzy3faQPXvZzsH6tiFLAaeGrDw1273u21bk+vUWQdByq2rzyRNIisqWY52TdayD70Kt5ODel60ynAp4GtUnJ4geyDDLIPvI7i7PL9j4gngK+QfcBWrsV8K8Wze0RsQfYBqvzLOojzbZIGV8X6lxplnyH75l69X7XKbhBJ7yVLFLen7b0K7Jo7P4dE1vmgXRHxPHAD2fv3GbImscpxWApMqzrvB0bEHflVVK3yJ8BBkt5D1jT4yzpiiIi4Fvg9WTM6kjYD/oesF+u26byaTfvn1VLgwKp4B0RElx33ns4Jqne6G3hR0imSBirrFLFb+pAAuAT4pqSdldld0tC07Cmy6yttuQr4qqQxKUn8B3BNRKzeyJjvIks0/yJpU2W/e2kGrs6V+bikfSS9BfgmcFdELI2IFWQfpp9L+3okbSfgwWQJZQXQX9JpwBa55U8Bo9V2l+ii9p+ImEOWWKbmYn0ZeF7SCLJrh3ltvlcRsRS4A/iWpAGSdie71ndFjbJryDponCVpcOpYcCLZh/dGkbSFpElk7+NPIuLBVEu+GDhf0jap3AhJH6tztVcChwOfSs8rfgD8q6Rd0zqHSPqn9lYUEcuAe8hqTv8TWWeVep0NTJX0drIa6GZk59Xq1Ilk/1zZp4ChSh1qcvGepTc7+2wt6aBObL/Xc4Iqt0oPrcrjF/W8KH3gNJNdGP8z2TfWS8iasgD+k+wD6QayNvUfkl00huwazI9Ts8Ona6z+UrJ/5lvTul8Djt+AfauO+XVgMnBgivf7wOGR9fSruBI4nazpZjzw2dyyY8g+wFcCu5J9ONdyPdm1ioVkzVivsW6zz0/T35WS7q3x+kL2P+dcsiS9GXAGWZPSC8CvyTpk5H0LmJ7eq5NrrOswsqbD5cAvgNNTEqzleLIvCIvJajlXku3rhpol6SWyY3sq2Tn3hdzyU8g6NNyZmi9/S655swMzgZ2BpyLi/srMiPgF8P+Aq9M6HyI7nzryY+DddNy8t46IeJCsI8rXUlPql8n+r54jq93NzJX9A9mXm8Xp/RpO1tFnJnBDOlZ3kjUbWqI3a8dm5SVpBtlF5umNjsV6F0n7ktUWR1ddA7UGcw3KzPqs9PuprwCXODmVjxOUmfVJkt5F1sV/O7LfZVnJuInPzMxKyTUoMzMrpQ0dMLFhhg0bFqNHj250GGZmtoHmz5//TER0+MPsHpegRo8ezbx58xodhpmZbSBJj3dcyk18ZmZWUk5QZmZWSk5QZmZWSj3uGlQtq1atYtmyZbz22muNDqUUBgwYwMiRI9l0000bHYqZ2QbrFQlq2bJlDB48mNGjRyOp4xf0YhHBypUrWbZsGWPGjGl0OGZmG6xXNPG99tprDB06tM8nJwBJDB061LVJM+vxCktQki6V9LSkh9pYLknflbRI0gOS9tzI7W3My3sVHwsz6w2KrEHNAA5oZ/mBZEPm70x2/5v/LjAWMzPrYQq7BhURt0oa3U6Rg4DL0t0w75S0paTtIuLJjd12a+vGrmFdU6d2XKZfv368+93vZtWqVfTv358jjjiCE044gTlz5nDKKacAsGjRIkaMGMHAgQPZfffdOfLII/nQhz7EzJkzaW5uBmDSpEmcfPLJTJw4sWt3wsysh2nkNagRrHujuGVp3nokTZU0T9K8FStWdEtwnTVw4EAWLFjAww8/zJw5c5g9ezZnnHEGH/vYx1iwYAELFiygqamJK664ggULFnDZZZcBMHLkSM4666wGR2/taW3NHrvsMhFJ6zx2Gb8LrfNb2WX8LustK+JLRiWW5uaW9bbXPLW5IbGU6bg4lvLGsiEa2Yuv1oWSmkOrR0Qr0ArQ1NRU+uHXt9lmG1pbW3nve99LS0tLu9eE3vOe97Bq1SrmzJnDfvvt141RWmedfPLc9WeOz6rrJ7euf0PbqePrqHoXoLtjKdNxcSzlj6UzGpmglgHb56ZHkt2aulfYcccdeeONN3j66afZdttt2y07ffp0pk+f7gRldWtubqG5uWXdmeO7uG3brMEa2cQ3Ezg89eb7P8ALXXH9qUzqvdfWBz/4QQBuu+22IsPpdSq10/yjpaWl0WGZWRcprAYl6SpgIjBM0jLgdGBTgIj4ATAb+DiwCPgb8IWiYmmExYsX069fP7bZZpu6yp966qmcddZZ9O/fK3473WVaWlo444wz1pk36ZhJNE9rZnjzcHaZtQsAJ7WeBJSnacLMNl6RvfgO62B5AMcWtf1GWrFiBV/84hc57rjj6v5N0v7778+//du/sXx5r2nl3CiVnpjDh7ewyy5zATjppOxvpSlr1kWzWHjvQgCmNU0DYPnpy12LMusleuXX9Xq6hXe1V199lXHjxq3tZv75z3+eE088sVPrOPXUUznooIMKirBnmjWrhYULbwFg2rQs2VdqUJVHnmtQZr1Hr0xQjbBmzZoOy8ydO3ed6YkTJ67TnXPy5Ml1X7fqK9wZwKzv6hVj8ZmZWe/jBGV1c685M+tObuKzurW0tKxtpqxurjQz62pOUFaX1vnZdZ8nX3pynWlwxwQzK4ab+MzMrJRcg7K61frd0aRjJjG11TUoM+t6vTJB5ZufukI9TViDBg3i5ZdfXjs9Y8YM5s2bxwUXXNDmayZOnMh5551HU1NTu+ueN28el112Gd/97nfXWzZ69GjmzZvHsGHDOoxxY9X63ZGZWVHcxFdyq1evpqmpqWZyKoJ76plZWThBFeyll15izJgxrFq1CoAXX3yR0aNHr53+yU9+wt57781uu+3G3XffDWRJYurUqey///4cfvjhzJ07l0mTJgGwcuVK9t9/f/bYYw+mTZvW5T/sbWlpYcKECUyYMIGIICKcoMysIZygukhlqKPK47TTTgNg8ODBTJw4kV//+tcAXH311XzqU59i0003BeCVV17hjjvu4Pvf/z5HHnnk2vXNnz+fX/3qV1x55ZXrbOeMM85gn3324b777mPy5Mk88cQT3bSHZmbdq1deg2qEyh11KyrXoACOPvpozjnnHD75yU/yox/9iIsvvnhtucMOy8bU3XfffXnxxRd5/vnngWzYo4EDB663nVtvvZWf//znAHziE59gq6226rJ9qAzQ+uST604DML7LNmNmVhfXoLrBBz7wAZYsWcItt9zCmjVr2G233dYuqx7tvDK9+eabt7m+ekdINzPryZygusnhhx/OYYcdxhe+sO5tr6655hoAbr/9doYMGcKQIUPaXc++++7LFVdcAcB1113Hc889V0zAZmYN1iub+Mo4ssFnP/tZpk+fvrZJr2KrrbZi77335sUXX+TSSy/tcD2nn346hx12GHvuuScTJkxg1KhRXRpnzdtbTDqd5vHDu3Q7ZmYd6ZUJqhHyv4ECmDJlClOmTFk7ffvtt3PwwQez5ZZbrp3X1nh21b3m8rflGDp0KDfccMPaZeeff/5GxV2t5u0tAPAtLsysezlBdYPjjz+e6667jtmzZzc6FDOzHsMJqht873vfa3QIZmY9jjtJmJlZKTlBmZlZKTlBmZlZKTlBmZlZKfXOThKtXdwlemrHv6tasmQJkyZN4qGHHlo7r6WlhUGDBvHQQw9xyy23MGTIEDbZZBMuvPBC3v/+9zNlyhTmzJnD4sWL2WyzzXjmmWdoampiyZIlXRu/mVkP5BpUNzn33HNZsGABZ599NtOmTVs7v1+/fnX9QNfMrK9xgupm++67L4sWLVo7fcIJJ3D++eezevXqBkZlZlY+TlDdbNasWbz73e9eOz1q1Cj22WcfLr/88gZGZWZWPk5QXaStEcYr87/2ta8xbtw4Wltb+eEPf7hOmW984xuce+65vPHGG4XHaWbWU/TOThINMHTo0PVGFn/22WcZM2YMkF2DOvjgg2u+9h3veAfjxo3j2muvLTxOM7OewjWoLjJo0CC22247brzxRiBLTr/5zW/YZ5996nr9qaeeynnnnVdkiGZmPUrvrEHV0S28CJdddhnHHnssJ510EpDdGmOnnXaq67W77rore+65J/fee2+RIZqZ9Ri9M0E1yNixY7n55pvXmz9jxoya5avnV27lnrd8+XKWL1++zrzhw4czfLjvz2RmvVuhCUrSAcB3gH7AJRFxdtXyUcCPgS1Tma9HhO9JkTN8+HBeeuklAN75znc2OBozs+5T2DUoSf2AC4EDgbHAYZLGVhWbDlwbEXsAhwLfLyoeMzPrWYrsJLEXsCgiFkfE68DVwEFVZQLYIj0fAixnA0XEhr601/GxMLPeoMgENQJYmptelubltQCfk7QMmA0cvyEbGjBgACtXrvQHM1lyWrlyJQMGDGh0KGZmG6XIa1C1frlanUEOA2ZExLclvR+4XNJuEbHOL1YlTQWmQjbyQrWRI0eybNkyVqxY0TWRl8xf//pXgLp/yDtgwABGjhxZZEhmZoUrMkEtA7bPTY9k/Sa8o4ADACLi95IGAMOAp/OFIqIVaAVoampar5q06aabrv1BbG/SOj8blf3bJ38bgJNaT1q7bOr4xnSlNzPrLkU28d0D7CxpjKS3kHWCmFlV5gngIwCS3gUMAHpnNcjMzDqlsAQVEauB44DrgUfJeus9LOlMSZNTsZOAYyTdD1wFTAlfSDIzMwr+HVT6TdPsqnmn5Z4/AnygyBjMzKxn8lh8ZmZWSh7qqORmXTSLhfcuBGBaU3Yn3knHTGJqqztJmFnv5gRVcs3Tmmme1tzoMMzMup2b+MzMrJScoMzMrJScoMzMrJScoMzMrJScoEqgpaUFSes8WlpaGh2WmVlDuRdfCbS0tDB37lyAtX/hzbH4zMz6ItegzMyslJygzMyslJygzMyslJygzMyslNxJosFaUz+IJ59cdxqA8d0ejplZabgGZWZmpeQEZWZmpeQEZWZmpeQEZWZmpeQEZWZmpeQEZWZmpVRXN3NJA4FREfFYwfH0SbNmtbBw4S0ATJsmACZNOp3m8cMbGZaZWUN1mKAkNQPnAW8BxkgaB5wZEZOLDq6vaG5uobm5pcYSDxZrZn1XPU18LcBewPMAEbEAGF1cSGZmZvUlqNUR8ULhkZiZmeXUcw3qIUmfAfpJ2hn4MnBHsWGZmVlfV08N6nhgV+DvwJXAC8BXigzKzMysnhrUJyLiVODUygxJ/wT8tLCozMysz6unBvWvdc4zMzPrMm3WoCQdCHwcGCHpu7lFWwCriw7MzMz6tvaa+JYD84DJwPzc/JeArxYZlJmZWZsJKiLuB+6XdGVErOrGmMzMzOrqJDFa0reAscCAysyI2LGwqMzMrM+rp5PEj4D/Jrvu9CHgMuDyIoMyMzOrJ0ENjIgbAUXE4xHRAny4npVLOkDSY5IWSfp6G2U+LekRSQ9LurL+0M3MrDerp4nvNUmbAH+UdBzwF2Cbjl4kqR9wIbAfsAy4R9LMiHgkV2Znsi7rH4iI5yR1uF4zM+sb6qlBnQC8lWyIo/HA54Ej6njdXsCiiFgcEa8DVwMHVZU5BrgwIp4DiIin6w3czMx6tw5rUBFxT3r6MvAFAEk71LHuEcDS3PQy4H1VZXZJ6/sd0A9oiYjfVK9I0lRgKsCoUaPq2LSZmfV07dagJL1f0sGVpjdJu6frRLfXsW7VmBdV0/2BnYGJwGHAJZK2XO9FEa0R0RQRTVtvvXUdmzYzs56uzQQl6VzgUuBTwK8lnQ7MAe4iSyodWQZsn5seSfbj3+oyv4qIVRHxZ+CxOtdtZma9XHtNfJ8A9oiI1yRtRZZcdo+IP9a57nuAnSWNIetYcSjwmaoyvySrOc2QNIysyW9xZ3bAzMx6p/aa+F6NiNcAUieGxzqRnIiI1cBxwPXAo8C1EfGwpDMlVW4Xfz2wUtIjwM3A1yJi5YbsiJmZ9S7t1aB2kjQzNz06Px0Rk2u8Zh0RMRuYXTXvtNzzAE5MDzMzs7XaS1DVXcK/XWQgZmZmee0NFntLdwZiZmaWV88Pdc3MzLqdE5SZmZVShwlK0m7dEYiZmVlePTWoH0i6W9I/1xrlwczMrAgdJqiI2Af4LNmoEPMkXSlpv8IjMzOzPq2ua1DpB7rTgVOACcB3Jf1B0v8tMjgzM+u76rkGtbuk88lGg/gw0BwR70rPzy84PjMz66PquWHhBcDFwDci4tXKzIhYLml6YZGZmVmf1m6CSnfFXRoRl9da3tZ8MzOzjdVuE19ErAGGSnpLN8VjZmYG1NfE9zjwuzRQ7CuVmRHxn4VFZWZmfV49CWp5emwCDC42HDMzs0yHCSoizgCQtHlEvNJReTMzs65QTzfz96cbCj6apt8j6fuFR2ZmZn1aPT/U/S/gY8BKgIi4H9i3yKDMzMzqHUliadWsNQXEYmZmtlY9nSSWStobiNTd/Muk5j4zM7Oi1FOD+iJwLDACWAaMS9NmZmaFqacGpYj4bOGRmJmZ5dRTg7pD0g2SjvL9oMzMrLvUcz+onclutbErcK+k/5X0ucIjMzOzPq3eXnx3R8SJwF7As8CPC43KzMz6vHp+qLuFpCMkXQfcATxJlqjMzMwKU08nifuBXwJnRsTvC47HzMwMqC9B7RgRUXgkZmZmOW0mKEn/FREnADMlrZegImJyoZGZmVmf1l4NqnK33PO6IxAzM7O8NhNURMxPf2/pvnDMzMwy7TXxPQjUuvYkICJi98KiMjOzPq+9Jr5J3RaFmZlZlfaa+B6vPJe0A7BzRPxW0sD2XmdmZtYV6vmh7jHAz4CL0qyRZL+L6pCkAyQ9JmmRpK+3U+5gSSGpqZ71mplZ71fPUEfHAh8AXgSIiD8C23T0Ikn9gAuBA4GxwGGSxtYoN5jsHlN31R/2xmtpaUHSOo+WlpYOl5mZWfeop6nu7xHxuiQAJPWndueJansBiyJicXrd1cBBwCNV5b4JnAOcXG/QXaGlpYW5c+cCrP1bzzIzM+se9dSgbpH0DWCgpP2AnwKz6njdCCB/q/hlad5akvYAto+I/21vRZKmSponad6KFSvq2LSZmfV09SSorwMrgAeBacBssttvdEQ15q2teUnaBDgfOKmjFUVEa0Q0RUTT1ltvXcemzcysp+uwiS8i3pD0S+CXEdGZ6ssyYPvc9EhgeW56MLAbMDc1H76dbFilyRExrxPbMTOzXqi9H+oKOB04jqw2JElrgO9FxJl1rPseYGdJY4C/AIcCn6ksjIgXgGG57c0FTu6O5NTamv198sl1pwEYn008+VK2sHX+mwunjp9adGhmZpa018R3AlnvvfdGxNCIeBvwPuADkr7a0YojYjVZcrseeBS4NiIelnSmJA80a2al4Z675dReE9/hwH4R8UxlRkQsTrd7v4Hs+lG7ImI22TWr/LzT2ig7sZ6Azcy6mnvullN7NahN88mpIl2H2rS4kMzMrAwaXbNsL0G9voHLzMxsAzU6KVTHMmHCBCZMmEBEEBHdGkt7TXzvkfRijfkCBhQUT7eZNauFhQuzO4lMm5b1iJ806XSaxw9n1kWzWHjvwmxZ07Rs2TGTmNrqThJmvUq+h1R1r6mpjfl/d3Pjm9obLLZfdwbS3ZqbW2hubqmxpJXmac00T2vu7pDMzMqhJIm7nh/qmpmZdTvfNsPM+ryWWbO4ZWHWrK9pWbP+6cuXd++1n5LUWsrENSgza4hSdQZobiYuumidh38H1XiuQZlZQ7gzQPk1umbpBGVmViKNTgrrxNLcTEtzVYexbmxudIIyMyuRRieFMnGCMrPu5c4AVid3kjAzs1JygjIzs1JygjLrQ8rUtdusI74GZdaHlKlrd5l6q1k5OUGZWUO4t5p1xE18ZmZWSq5BmfUF7tptPZBrUGZmVkpOUGZmVkpOUGZmVkq+BmXWh7hrt/UkTlBmfYi7dltP4iY+MzMrJScoMzMrJScos4J5/DuzDeMEZb1SmZJCS0sLEyZMYMKECUQEEeEEZVYHd5KwXqlMg6Ka2YZxgjIriocXMtsoTlDWuzgpmPUavgZlZmal5ARlXaJMnRLKpjJ6wy0LF6Jp09C0aT42ZnVwE591ibJ1SijTkD4evcFswxRag5J0gKTHJC2S9PUay0+U9IikByTdKGmHIuPpbVxraVtLczNx0UXrPHxszHqWwmpQkvoBFwL7AcuAeyTNjIhHcsXuA5oi4m+SvgScAxxSVEy9TWlqLZVOCNWdEsA1BTPbYEXWoPYCFkXE4oh4HbgaOChfICJujoi/pck7gZEFxmNmZj1IkdegRgBLc9PLgPe1U/4o4LpaCyRNBaYCjBo1qqvi69lcazGzXq7IGpRqzIuaBaXPAU3AubWWR0RrRDRFRNPWW2/dhSFaV6nZU23WrEaHZWY9WJE1qGXA9rnpkcDy6kKSPgqcCkyIiL8XGI8VqGZPNTOzjVBkDeoeYGdJYyS9BTgUmJkvIGkP4CJgckQ8XWAsvZJrLWbWmxVWg4qI1ZKOA64H+gGXRsTDks4E5kXETLImvUHATyUBPBERk4uKqbdxrcXMerNCf6gbEbOB2VXzTss9/2iR2zczs57LQx2ZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUF1km+zbmbWPQodi683Ks1t1s3MejnXoMzMrJRcg+oM32bdzKzbuAZlZmal5BpUJ1XuYgugadMAOH3SJFpcgzIz61JOUJ3ku9iamXUPN/GZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUF4t6TkAAAM80lEQVSZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpOUGZmVkpFZqgJB0g6TFJiyR9vcbyzSRdk5bfJWl0kfGYmVnPUViCktQPuBA4EBgLHCZpbFWxo4DnIuIdwPnA/ysqHjMz61mKrEHtBSyKiMUR8TpwNXBQVZmDgB+n5z8DPiJJBcZkZmY9hCKimBVLBwMHRMTRafrzwPsi4rhcmYdSmWVp+k+pzDNV65oKTE2T7wQeKyTo9Q0DnumwVPdwLG0rUzyOpTbHUltfjWWHiNi6o0L9CwygVk2oOhvWU4aIaAVauyKozpA0LyKaunu7tTiWtpUpHsdSm2OpzbG0r8gmvmXA9rnpkcDytspI6g8MAZ4tMCYzM+shikxQ9wA7Sxoj6S3AocDMqjIzgSPS84OBm6KoNkczM+tRCmvii4jVko4Drgf6AZdGxMOSzgTmRcRM4IfA5ZIWkdWcDi0qng3U7c2K7XAsbStTPI6lNsdSm2NpR2GdJMzMzDaGR5IwM7NScoIyM7NScoKiriGZ9pV0r6TV6fddjYzlREmPSHpA0o2SdmhgLF+U9KCkBZJurzFSSLfFkit3sKSQVFh32TqOyxRJK9JxWSDp6EbFksp8Op0zD0u6slGxSDo/d0wWSnq+gbGMknSzpPvS/9LHGxjLDul/+QFJcyWNLDCWSyU9nX6DWmu5JH03xfqApD2LiqUuEdGnH2QdOP4E7Ai8BbgfGFtVZjSwO3AZcHCDY/kQ8Nb0/EvANQ2MZYvc88nAbxoVSyo3GLgVuBNoauBxmQJcUJJzd2fgPmCrNL1NI9+jXPnjyTpONeq4tAJfSs/HAksaGMtPgSPS8w8Dlxd4zuwL7Ak81MbyjwPXkf1G9f8AdxUVSz0P16DqGJIpIpZExAPAGyWI5eaI+FuavJPs92WNiuXF3OTm1PiRdXfFknwTOAd4raA4OhNLd6gnlmOACyPiOYCIeLqBseQdBlzVwFgC2CI9H8L6v9HszljGAjem5zfXWN5lIuJW2v+t6UHAZZG5E9hS0nZFxdMRJygYASzNTS9L83pCLEeRfdtpWCySjk1DVJ0DfLlRsUjaA9g+Iv63oBjqjiX5VGoi+Zmk7Wss765YdgF2kfQ7SXdKOqCBsQBZkxYwBripgbG0AJ+TtAyYTVaja1Qs9wOfSs//ERgsaWhB8XSkTJ+HTlDUOdxSN6k7FkmfA5qAcxsZS0RcGBE7AacA0xsRi6RNyEbDP6mg7dcdSzILGB0RuwO/5c0BkRsRS3+yZr6JZLWWSyRt2aBYKg4FfhYRawqIo95YDgNmRMRIsmaty9N51IhYTgYmSLoPmAD8BVhdQCz1KNPnoRMU9Q3JVKpYJH0UOBWYHBF/b2QsOVcDn2xQLIOB3YC5kpaQtZ3PLKijRIfHJSJW5t6Xi4HxBcRRVyypzK8iYlVE/JlsoOWdGxRLxaEU17xXbyxHAdcCRMTvgQFkg6V2eywRsTwi/m9E7EH2f01EvFBALPUo0+ehO0mQfcNcTNbkULmIuWsbZWdQbCeJDmMB9iC76Lpzo49LPgagmWyEkIa+R6n8XIrrJFHPcdku9/wfgTsbGMsBwI/T82FkzTdDG/Uekd2NYAlpkIAGHpfrgCnp+bvIPoS7PKY6YxkGbJKenwWcWdSxSdsYTdudJD7Bup0k7i4ylg5jbeTGy/Igq+IvTB/8p6Z5Z5LVUADeS/bN4hVgJfBwA2P5LfAUsCA9ZjYwlu8AD6c4bm4vaRQdS1XZuRSUoOo8Lt9Kx+X+dFz+oYGxCPhP4BHgQeDQRr5HZNd+zi4qhk4cl7HA79J7tADYv4GxHAz8MZW5BNiswFiuAp4EVqXPtKOALwJfzJ0vF6ZYHyzy/6ieh4c6MjOzUvI1KDMzKyUnKDMzKyUnKDMzKyUnKDMzKyUnKDMzKyUnqD5A0po0gvRDkmZ1NJKApC0l/XNuerikn3VRLOemUbXPrZqfHwH8EUnHdMX2qrYxt6Mf70o6QdJbc9Ozu2LkBUktkv6Sex8md/L14/Ijbkua3N6o7qnMHRsRb1HHodPnUnrf5uWmmyTN7eA1oyV9ZgPD7Gi9NUcCt67nBNU3vBoR4yJiN7KBIo/toPyWwNoEFdkv3bvqNiPTgD0j4ms1ll0TEePIhuX5D0nbdtE2O+MEYO0Hc0R8PCK66rYQ56f9+yfg0nqH1pHUHxhH9nuaSlwzI+Ls9l4XEXtvRKyFHIeNOJe2kXRgJ8qPBro0QUnq15Xrs445QfU9vycN/ihpULoPzb3K7utUGUX5bGCn9G3/3Py3RkkDJP0olb9P0oeqN5DuKXNuqik8KOmQNH8m2ajnd1Xm1RLZiNt/AnaQ9DZJv0wDr94pafe0rhZJl0u6SdIfKzUuSRMlrR0wVtIFkqbUiPG/Jc1Ltbkz0rwvA8OBmyXdnOYtkTQsPT8x7dNDkk5I80ZLelTSxWldN0ga2N4bEBGPko21NkxSs6S70rH8bSUpp/1rlXQD2W1ezgQOSe/JIanGeUEqu62kX0i6Pz32TvNfzh2TW1OZRyT9oJIcO3sc2ttfSe9N79PvK+9/jeOeP5emSPq5pN+k9/Ccdg7budQY61FSv7Ste9K2p6VFZwMfTMfrq8pqgJVz5z5Jp6Xn35R0dDvn7ERl9426kuyHq/lt75jW9d723m/bCI38lbAf3fMAXk5/+5Hde+aANN2fdE8nsuFWFpH9knw0uaFQ8tNkA7L+KD3/B+AJYEDV9j4FzEnb2zaV2S4fS40Yp5DuoUR275yngbcB3wNOT/M/DCxIz1vIRgEYyJtD+Awnq339b269F/DmkDZzSb+MB96WOyZzgd3T9BJgWO71S9L6x5N9QG0ODCIbKWKPdGxWA+NS+WuBz9XYvxbg5PT8faShdYCtYO0P5o8Gvp0rPx8YWH18ahyva4ATcvszpOp9n0h2C5Id0/I5pCG7NuA4tLm/wEPA3un52dQYTod1z6UpZMMADSEbC+9xshHpq18zl2xg5JvI7ofWBMxNy6YC09PzzYB5ZMMKTWTd8+DrZC0HWwD3ANen+TeTDb9U85xN63kFGJOPP73mvspx8KOYh2tQfcNASQvIhml6G9k/ImQfkP8h6QGyIZRGkP1ztmcf4HKAiPgD2YfKLjXKXBURayLiKeAWsuGiOnJIivMqYFpEPFu1vZuAoZKGpPK/iohXI+IZsg+averYRsWnJd1L9iGzK9nQN+3ZB/hFRLwSES8DPwc+mJb9OSIWpOfzyT7Eavlq2r/zgEMi+8QbCVwv6UHgaymWipkR8Wod+/Jh4L8B0jGvNdDo3ZHdk2gN2fHdJ83v7HGAGvur7PrU4IioXPeq9869N0bECxHxGtlwTDu0U/bfWb8WtT9weDqudwFDqT0Y7m1kN+vbB/g1MEjZNbbREfEY7Z+zd0c20G7F1sCvyBLzAqwwTlB9w6uRXfvYgWzAyso1qM+S/bONT8ufIvsm255aw/FvSJlaronsWtn7IuIX7awrqv7m569m3fN6vf2RNIbsFgcfieyWGL+uVa76Ze0sy48ov4asZlrL+Wn/PhgRt6V53yOrCb2b7PpcPo5XOoipM9Y7Vht4HKD2/m7oe17vsat8QRlANohphYDj03EdFxFjIuKGGi+/h6zm9UGyuy7fR3Yzx/m59bSl+n14gazG/oF2XmNdwAmqD0nfrL8MnCxpU7KmlacjYpWya0mVb68vkd3CopZbyRIbknYBRpHdwqG6zCHp+sDWZN9c797AsPPbmwg8E2/eyfcgZdfEhpI1xdxDVqMbK2mzVNP6SI11bkH2ofNCuuaTv/je1r7fCnxS0lslbU42SvltNcp11hCy+/8AHNFOufbekxuBL8HaazJb1Cizl6Qx6drTIcDtbNhxqCmyO/a+JKmSPA6t97WddBbwL7np64EvpfMZSbuk92ed+CO7m+1S4NNkd6K+jSw5V97Dzpyzr5PdWuZwFdBT0N7kBNXHRMR9ZNduDgWuAJqUdeH9LPCHVGYl8Lt0wbj6hojfB/qlJqlryK7vVN+T6hfAA2k7NwH/EhF/3cCQW1KMD5Bd18h/iN9N9q3/TuCbkfUQW0p2XeSBtH/3Va8wIu5P8x8GLiUb1bqiFbiu0jkg95p7yW63cjdZU9Il6VhurBbgp5JuA55pp9zNZIl3gdbvYPIV4EPpPZnPus2EFb8nXRcC/kzWXNnp49CBo4BWSb8nq5F0+T2NImI2sCI36xKypsF7U+eLi8hqYQ8Aq1Onka+msrcBT0XE39LzkbyZoDp1zkbEK8Aksmbbwm7R3td5NHPrkSS1kHUCOK/RsZRdqnmeHBGTCt7OoHR9DmW/0douIr5S5Datd2uzvdfMrJM+IelfyT5XHifrpWe2wVyDMjOzUvI1KDMzKyUnKDMzKyUnKDMzKyUnKDMzKyUnKDMzK6X/D03xVijYH4H9AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "deliv_return_ratio.local_label.title = 'Effect of Population Ratio on Delivery Rate'\n",
    "plot_plots(deliv_return_ratio.local, deliv_return_ratio.local_err, deliv_return_ratio.local_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cost_return_ratio.local_cost_label.title = 'Effect of Population Ratio on Network Cost'\n",
    "cost_return_ratio.local_cost_label.y_label = 'Daily Cost'\n",
    "plot_plots(cost_return_ratio.local_cost, cost_return_ratio.local_cost_err, cost_return_ratio.local_cost_label, additional_data=cost_return_ratio.additional_data_dict)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "delay_return_ratio.local_label.title = 'Effect of Population Ratio on Message Delay'\n",
    "delay_return_ratio.local_label.y_label = 'Delivery Latency'\n",
    "plot_plots(delay_return_ratio.local, delay_return_ratio.local_err, delay_return_ratio.local_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2400000000000078\n",
      "1.3710747456877572\n",
      "[0.3870000000000002, 0.7939999999999999, 0.9470000000000003, 0.9819999999999999, 0.9990000000000001, 0.9990000000000001, 0.9990000000000001, 1.0, 0.9990000000000001, 1.0]\n",
      "[14.73, 16.4, 12.7, 9.425, 5.1, 4.49, 3.34, 2.455, 1.655, 1.15]\n",
      "0.365\n"
     ]
    }
   ],
   "source": [
    "print((np.mean(deliv_return_ratio.local.hybrid)-np.mean(deliv_return_ratio.local.dtn))*100)\n",
    "print((np.mean(deliv_return_ratio.local.hybrid)-np.mean(deliv_return_ratio.local.dtn))*200/(np.mean(deliv_return_ratio.local.hybrid)+np.mean(deliv_return_ratio.local.dtn)))\n",
    "print(deliv_return_ratio.local.hybrid)\n",
    "print(delay_return_ratio.local.hybrid)\n",
    "print(max(deliv_return_ratio.local.internet))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}