Merge 997e696 into fcda0bd

scripts/demand.py

@@ -0,0 +1,25 @@
+def demand_model(monthly_traffic_GB, percent_of_traffic):
+    """
+    Calculate the demand density per area (Mbps/km2):
+
+    Parameters
+    ----------
+    params : dict.
+        Contains all simulation parameters.
+
+    Returns
+    -------
+    results : float
+            demand density_mbps_sqkm.
+
+    """
+    area_km = 1
+    adoption_rate = 0.1
+    population_density = 5
+    active_users_per_sqkm = population_density * (adoption_rate / 100)
+    hourly_MB = (monthly_traffic_GB / 30) * 1000 * percent_of_traffic
+    hourly_mbps = hourly_MB * (8 / 3600)
+    hourly_active_user_density = (active_users_per_sqkm * percent_of_traffic) / area_km
+    demand_density_mbps_sqkm = hourly_active_user_density / hourly_mbps
+
+    return demand_density_mbps_sqkm

scripts/inputs.py

@@ -29,6 +29,8 @@
         'number_of_channels': 8, #Number of channels per satellite
         'overbooking_factor': 20, # 1 in 20 users access the network
         'polarization':2,
+        'monthly_traffic_GB': 25,
+        'percent_of_traffic': 15,
         'fuel_mass': 488370,
         'fuel_mass_1': 0,
         'fuel_mass_2': 0,
@@ -67,6 +69,8 @@
         'number_of_channels': 8, #Number of channels per satellite
         'overbooking_factor': 20, # 1 in 20 users access the network
         'polarization': 2,
+        'monthly_traffic_GB': 25,
+        'percent_of_traffic': 15,
         'fuel_mass': 218150,
         'fuel_mass_1': 7360,
         'fuel_mass_2': 0,
@@ -105,6 +109,8 @@
         'number_of_channels': 8, #Number of channels per satellite
         'overbooking_factor': 20, # 1 in 20 users access the network
         'polarization': 2,
+        'monthly_traffic_GB': 25,
+        'percent_of_traffic': 15,
         'fuel_mass': 0,
         'fuel_mass_1':10000,
         'fuel_mass_2': 480000,

scripts/uq_inputs.py

@@ -1,13 +1,15 @@
 import numpy as np
 import pandas as pd
-from random import gauss
+import random
+import decimal
+from random import*
 from inputs import parameters, lut
 
 def uq_inputs_generator():
-
+    path = "/Users/osoro/Codebase/globalsat/data/"
     uq_parameters = []
 
-    N = 5 #Number of datapoints to generate
+    N = 1000 #Number of datapoints to generate
 
     for number in range(N):
         for key, item in parameters.items():
@@ -18,32 +20,50 @@ def uq_inputs_generator():
             mu = item['mu']
             sigma = item['sigma']
             total_area_earth_km_sq = item["total_area_earth_km_sq"]
-            altitude_km = gauss(item["altitude_km"], 5)
-            dl_frequency_Hz = gauss(item["dl_frequency"], 0.1)
+            altitude_km = uniform((item["altitude_km"] - 5), (item["altitude_km"] + 5))
+            dl_frequency_Hz = uniform((item["dl_frequency"] - 0.1), (item["dl_frequency"] + 0.1))
             dl_bandwidth_Hz = item["dl_bandwidth"]
             speed_of_light = item["speed_of_light"]
-            antenna_diameter_m = gauss(item["antenna_diameter"], 0.2)
-            antenna_efficiency = gauss(item["antenna_efficiency"], 0.1)
+            antenna_diameter_m = uniform((item["antenna_diameter"] - 0.2), 
+                                 (item["antenna_diameter"] + 0.2))
+            antenna_efficiency = uniform((item["antenna_efficiency"] - 0.1), 
+                                 (item["antenna_efficiency"] + 0.1))
             power_dBw = item["power"]
-            receiver_gain_dB = gauss(item["receiver_gain"], 5)
-            earth_atmospheric_losses_dB = gauss(item["earth_atmospheric_losses"], 3)
-            all_other_losses_dB = gauss(item["all_other_losses"], 0.2)
+            receiver_gain_dB = uniform((item["receiver_gain"] - 5), 
+                               (item["receiver_gain"] + 5))
+            earth_atmospheric_losses_dB = uniform((item["earth_atmospheric_losses"] - 3), 
+                                          (item["earth_atmospheric_losses"] + 3))
+            all_other_losses_dB = uniform((item["all_other_losses"] - 0.2), 
+                                  (item["all_other_losses"] + 0.2))
             number_of_channels = item["number_of_channels"]
             polarization = item["polarization"]
+            monthly_traffic = uniform((item["monthly_traffic_GB"]), 
+                              (item["monthly_traffic_GB"] + 10))
+            traffic_percent = item["percent_of_traffic"]
             fuel_mass_kg = item["fuel_mass"]
             fuel_mass_1_kg = item["fuel_mass_1"]
             fuel_mass_2_kg = item["fuel_mass_2"]
             fuel_mass_3_kg = item["fuel_mass_3"]
-            satellite_launch_cost = gauss(item["satellite_launch_cost"], 10000000)
-            ground_station_cost = gauss(item["ground_station_cost"], 5000000)
-            spectrum_cost = gauss(item["spectrum_cost"], 20000000)
-            regulation_fees = gauss(item["regulation_fees"], 2000000)
-            digital_infrastructure_cost = gauss(item["digital_infrastructure_cost"], 1000000)
-            ground_station_energy = gauss(item["ground_station_energy"], 1000000)
-            subscriber_acquisition = gauss(item["subscriber_acquisition"], 10000000)
-            staff_costs = gauss(item["staff_costs"], 10000000)
-            research_development = gauss(item["research_development"], 1000000)
-            maintenance = gauss(item["maintenance"], 1000000)
+            satellite_launch_cost = uniform((item["satellite_launch_cost"] - 10000000), 
+                                    (item["satellite_launch_cost"] + 10000000))
+            ground_station_cost = uniform((item["ground_station_cost"] - 5000000), 
+                                  (item["ground_station_cost"] + 5000000))
+            spectrum_cost = uniform((item["spectrum_cost"] - 20000000), 
+                            (item["spectrum_cost"] + 20000000))
+            regulation_fees = uniform((item["regulation_fees"] - 2000000), 
+                              (item["regulation_fees"] + 2000000))
+            digital_infrastructure_cost = uniform((item["digital_infrastructure_cost"] - 1000000), 
+                                          (item["digital_infrastructure_cost"] + 1000000))
+            ground_station_energy = uniform((item["ground_station_energy"] - 1000000), 
+                                    (item["ground_station_energy"] + 1000000))
+            subscriber_acquisition = uniform((item["subscriber_acquisition"] - 10000000), 
+                                     (item["subscriber_acquisition"] + 10000000))
+            staff_costs = uniform((item["staff_costs"] - 10000000), 
+                          (item["staff_costs"] + 10000000))
+            research_development = uniform((item["research_development"] - 1000000), 
+                                   (item["research_development"] + 1000000))
+            maintenance = uniform((item["maintenance"] - 1000000), 
+                          (item["maintenance"] + 1000000))
             discount_rate = item["discount_rate"]
             assessment_period_year = item["assessment_period"]
 
@@ -67,6 +87,8 @@ def uq_inputs_generator():
                                   "all_other_losses_dB": all_other_losses_dB,
                                   "number_of_channels": number_of_channels,
                                   "polarization": polarization,
+                                  "monthly_traffic_GB": monthly_traffic,
+                                  "percent_of_traffic": traffic_percent,
                                   "fuel_mass_kg": fuel_mass_kg,
                                   "fuel_mass_1_kg": fuel_mass_1_kg,
                                   "fuel_mass_2_kg": fuel_mass_2_kg,
@@ -85,7 +107,7 @@ def uq_inputs_generator():
                                   "assessment_period_year": assessment_period_year})
 
     df = pd.DataFrame.from_dict(uq_parameters)
-    df.to_csv("uq_parameters.csv")
+    df.to_csv(path + "uq_parameters.csv")
 
     return df.shape
 uq_inputs_generator()

scripts/uq_run.py

@@ -16,12 +16,16 @@
 import globalsat.sim as gb
 from inputs import lut
 from cost import cost_model
+from demand import demand_model
+pd.options.mode.chained_assignment = None #Suppress pandas outdate errors.
 
 #Import the data.
 
-df = pd.read_csv("uq_parameters.csv")
+data_path = "/Users/osoro/Codebase/globalsat/data/"
+df = pd.read_csv(data_path + "uq_parameters.csv")
 uq_dict = df.to_dict('records') #Convert the csv to list
 
+path = "/Users/osoro/Codebase/globalsat/results/"
 results = []
 for item in uq_dict:
     constellation = item["constellation"]
@@ -67,6 +71,9 @@
                    spectral_efficiency, item["number_of_channels"], 
                    item["polarization"])
 
+    demand_density_mbps_sqkm = demand_model(item["monthly_traffic_GB"], 
+                               item["percent_of_traffic"])
+
     emission_dict = gb.calc_per_sat_emission(item["constellation"], item["fuel_mass_kg"],
                     item["fuel_mass_1_kg"], item["fuel_mass_2_kg"], item["fuel_mass_3_kg"])
 
@@ -78,6 +85,18 @@
                            item["discount_rate"], item["assessment_period_year"])             
     cost_per_capacity = total_cost_ownership / sat_capacity* number_of_satellites
 
+    aluminium_oxide_emissions = emission_dict['alumina_emission']
+    sulphur_oxide_emissions = emission_dict['sulphur_emission']
+    carbon_oxide_emissions = emission_dict['carbon_emission']
+    cfc_gases_emissions = emission_dict['cfc_gases']
+    particulate_matter_emissions = emission_dict['particulate_matter']
+    photochemical_oxidation_emissions = emission_dict['photo_oxidation']
+    total_emissions = aluminium_oxide_emissions + sulphur_oxide_emissions \
+                      + carbon_oxide_emissions + cfc_gases_emissions \
+                      + particulate_matter_emissions \
+                      + photochemical_oxidation_emissions
+
+
     results.append({"constellation": constellation, 
                     "signal_path": distance,
                     "satellite_coverage_area_km": satellite_coverage_area_km,
@@ -93,20 +112,86 @@
                     "agg_capacity": agg_capacity,
                     "capacity_per_single_satellite": sat_capacity,
                     "capacity_per_area_mbps/sqkm": agg_capacity/item["coverage_area_per_sat_sqkm"],
+                    "demand_density_mbps_sqkm": demand_density_mbps_sqkm,
                     "total_cost_ownership": total_cost_ownership,
                     "cost_per_capacity": cost_per_capacity,
-                    "aluminium_oxide_emissions_t":emission_dict['alumina_emission']/1000,
-                    "sulphur_oxide_emissions_t": emission_dict['sulphur_emission']/1000,
-                    "carbon_oxide_emissions_t": emission_dict['carbon_emission']/1000,
-                    "cfc_gases_emissions_t": emission_dict['cfc_gases']/1000,
-                    "particulate_matter_emissions_t": emission_dict['particulate_matter']/1000,
-                    "photochemical_oxidation_emissions_t": emission_dict['photo_oxidation']/1000,
-                    "total_emissions_t": ((emission_dict['alumina_emission'])
-                                       + (emission_dict['sulphur_emission'])
-                                       + (emission_dict['carbon_emission'])
-                                       + (emission_dict['cfc_gases']) 
-                                       + (emission_dict['particulate_matter'])
-                                       + (emission_dict['photo_oxidation']))/1000})
+                    "aluminium_oxide_emissions": aluminium_oxide_emissions,
+                    "sulphur_oxide_emissions": sulphur_oxide_emissions,
+                    "carbon_oxide_emissions": carbon_oxide_emissions,
+                    "cfc_gases_emissions": cfc_gases_emissions,
+                    "particulate_matter_emissions": particulate_matter_emissions,
+                    "photochemical_oxidation_emissions": photochemical_oxidation_emissions,
+                    "total_emissions_t": total_emissions})
 
     df = pd.DataFrame.from_dict(results)
-    df.to_csv("uq_results.csv")
+    df.to_csv(path + "uq_results.csv")
+
+data_path = '/Users/osoro/Codebase/globalsat/results/'
+results_path = '/Users/osoro/Codebase/globalsat/results/'
+
+def process_mission_results(data_path, results_path):
+    """
+    Prepare full emission results for the three constellations
+    
+    """
+    df = pd.read_csv(data_path + "uq_results.csv", index_col=False)
+
+    #Select the columns to use.
+    df = df[['constellation', 'aluminium_oxide_emissions',
+       'sulphur_oxide_emissions', 'carbon_oxide_emissions',
+       'cfc_gases_emissions', 'particulate_matter_emissions',
+       'photochemical_oxidation_emissions']]
+
+    #Create new columns to store the results.
+    df[["starlink_aluminium_emissions", "starlink_sulphur_emissions", 
+    "starlink_carbon_emissions", "starlink_cfc_emissions", 
+    "starlink_particulate_emissions", "starlink_oxidation_emissions", 
+    "starlink_total_emissions", "oneweb_aluminium_emissions", 
+    "oneweb_sulphur_emissions", "oneweb_carbon_emissions", 
+    "oneweb_cfc_emissions", "oneweb_particulate_emissions", 
+    "oneweb_oxidation_emissions", "oneweb_total_emissions", 
+    "kuiper_aluminium_emissions", "kuiper_sulphur_emissions", 
+    "kuiper_carbon_emissions", "kuiper_cfc_emissions", 
+    "kuiper_particulate_emissions", "kuiper_oxidation_emissions", 
+    "kuiper_total_emissions"]] = ""
+
+    #Iterate through the rows and store the results.
+    for i in range(len(df)):
+        if df["constellation"].loc[i] == "Starlink":
+            df["starlink_aluminium_emissions"].loc[i] = (df["aluminium_oxide_emissions"].loc[i]) * 74
+            df["starlink_sulphur_emissions"].loc[i] = (df["sulphur_oxide_emissions"].loc[i]) * 74
+            df["starlink_carbon_emissions"].loc[i] = (df["carbon_oxide_emissions"].loc[i]) * 74
+            df["starlink_cfc_emissions"].loc[i] = (df["cfc_gases_emissions"].loc[i]) * 74
+            df["starlink_particulate_emissions"].loc[i] = (df["particulate_matter_emissions"].loc[i]) * 74
+            df["starlink_oxidation_emissions"].loc[i] = (df["photochemical_oxidation_emissions"].loc[i]) * 74
+            df["starlink_total_emissions"].loc[i] = df["starlink_aluminium_emissions"].loc[i] \
+                + df["starlink_sulphur_emissions"].loc[i] + df["starlink_carbon_emissions"].loc[i] \
+                + df["starlink_cfc_emissions"].loc[i] + df["starlink_particulate_emissions"].loc[i] \
+                + df["starlink_oxidation_emissions"].loc[i] 
+        elif df["constellation"].loc[i]=="OneWeb":
+            df["oneweb_aluminium_emissions"].loc[i] = (df["aluminium_oxide_emissions"].loc[i]) * 20
+            df["oneweb_sulphur_emissions"].loc[i] = (df["sulphur_oxide_emissions"].loc[i]) * 20
+            df["oneweb_carbon_emissions"].loc[i] = (df["carbon_oxide_emissions"].loc[i]) * 20
+            df["oneweb_cfc_emissions"].loc[i] = (df["cfc_gases_emissions"].loc[i]) * 20
+            df["oneweb_particulate_emissions"].loc[i] = (df["particulate_matter_emissions"].loc[i]) * 20
+            df["oneweb_oxidation_emissions"].loc[i] = (df["photochemical_oxidation_emissions"].loc[i]) * 20
+            df["oneweb_total_emissions"].loc[i] = df["oneweb_aluminium_emissions"].loc[i] \
+                + df["oneweb_sulphur_emissions"].loc[i] + df["oneweb_carbon_emissions"].loc[i] \
+                + df["oneweb_cfc_emissions"].loc[i] + df["oneweb_particulate_emissions"].loc[i] \
+                + df["oneweb_oxidation_emissions"].loc[i] 
+        elif df["constellation"].loc[i]=="Kuiper":
+            df["kuiper_aluminium_emissions"].loc[i] = (df["aluminium_oxide_emissions"].loc[i]) * 54
+            df["kuiper_sulphur_emissions"].loc[i] = (df["sulphur_oxide_emissions"].loc[i]) * 54
+            df["kuiper_carbon_emissions"].loc[i] = (df["carbon_oxide_emissions"].loc[i]) * 54
+            df["kuiper_cfc_emissions"].loc[i] = (df["cfc_gases_emissions"].loc[i]) * 54
+            df["kuiper_particulate_emissions"].loc[i] = (df["particulate_matter_emissions"].loc[i]) * 54
+            df["kuiper_oxidation_emissions"].loc[i] = (df["photochemical_oxidation_emissions"].loc[i]) * 54
+            df["kuiper_total_emissions"].loc[i] = df["kuiper_aluminium_emissions"].loc[i] \
+                + df["kuiper_sulphur_emissions"].loc[i] + df["kuiper_carbon_emissions"].loc[i] \
+                + df["kuiper_cfc_emissions"].loc[i] + df["kuiper_particulate_emissions"].loc[i] \
+                + df["kuiper_oxidation_emissions"].loc[i]
+        else:
+            break
+    store_results = df.to_csv(results_path + "mission_emission_results.csv")
+    return store_results
+process_mission_results(data_path, results_path)