SPACEX FALCON 9 – esempio di previsione del successo o meno dell’atterraggio del primo stadio sulla base di alcuni dati di input – I parte –
Settembre 6, 2023Ora, ci servono altre specifiche riguardanti il “payloads” e cioè il carico. Anche per quest’ultimo vi sono delle API specifiche. Allo stesso modo per quanto fatto per il rocket aggiungerò una desinenza ‘pay’ al nome identificativo dell’elemento del payloads. Nella seguente tabella sono riportate le variabili.
| Nome identificativo elemento ‘payloads’ | Descrizione | Codice |
|---|---|---|
| pay_dragon_capsule | Identificativo della capsula | response[‘dragon’][‘capsule’] |
| pay_mass_returned_kg | Si riferisce alla massa totale (in chilogrammi) che la capsula Dragon ha riportato sulla Terra da una missione spaziale. Potrebbe essere carico utile, campioni scientifici, attrezzature, ecc | response[‘dragon’][‘mass_returned_kg’] |
| pay_mass_returned_lbs | Questo è simile al campo precedente ma esprime la massa in libbre invece che in chilogrammi. | response[‘dragon’][‘mass_returned_lbs’] |
| pay_flight_time_sec | Il tempo totale di volo della capsula, misurato in secondi. Questo rappresenta la durata della missione dal lancio al rientro. | response[‘dragon’][‘flight_time’] |
| pay_manifest | Questo campo potrebbe contenere informazioni o un elenco di oggetti e attrezzature che erano a bordo della capsula durante la sua missione. In altre parole, è una sorta di elenco dettagliato del carico o del contenuto della capsula. | response[‘dragon’][‘manifest’] |
| pay_water_landing | Un campo booleano (vero o falso) che indica se la capsula ha effettuato un ammaraggio nell’acqua al suo rientro sulla Terra. La capsula Dragon di SpaceX è conosciuta per i suoi ammaraggi nell’oceano al termine delle missioni. | response[‘dragon’][‘water_landing’] |
| pay_land_landing | Anche questo è un campo booleano, ma indica se la capsula è atterrata sulla terraferma. Alcune capsule spaziali sono progettate per atterrare su terra, ma per quanto ne sappiamo, le capsule Dragon di SpaceX tipicamente ammarano in acqua. | response[‘dragon’][‘land_landing’] |
| pay_name | Nome del carico, Per esempio nel caso di un satellite, qui sarà presente il nome del satellite. | response[‘name’] |
| pay_type | Il tipo del carico: satellite, o altro. | response[‘type’] |
| pay_reused | Indica se il payload (carico) è stato riutilizzato da un lancio precedente. Il valore “false” indica che non è stato riutilizzato. | response[‘reused’] |
| pay_launch | Id univoco del lancio | response[‘launch’] |
| pay_customers | Il comittente del carico. | response[‘customers’] |
| pay_norad_ids | L’ID NORAD è un identificatore assegnato dall’organizzazione North American Aerospace Defense Command (o, semplicemente, NORAD) a tutti gli oggetti artificiali nell’orbita terrestre (compresi i detriti!). L’ID NORAD è anche chiamato Satellite Catalog Number o USSPACECOM object number. | response[‘norad_ids’] |
| pay_nationalities | Le nazionalità associate a questo satellite. | response[‘nationalities’] |
| pay_manufactures | Costruttore del carico. | response[‘manufactures’] |
| pay_mass_kg | Massa del carico in Kg | response[‘mass_kg’] |
| pay_mass_lbs | Massa del carico in libbre | response[‘mass_lbs’] |
| pay_orbit | L’orbita prevista dal carico. Per esempio, il valore ‘MEO’ o medium Earth Orbit è un orbita attorno alla terra di un altitudine compresa tra i 2000 e i 35786 km. | response[‘orbit’] |
| pay_reference_system | Sistema di riferimento geocentrico. E’ un sistema di coordinate geografiche che ha come riferimento il modello sferoide XYZ misurato dal centro della terra. | response[‘reference_system’] |
| pay_regime | Orbita semi-sincrona: un’orbita con un periodo orbitale pari alla metà del periodo di rotazione medio del corpo in orbita e nella stessa direzione di rotazione di quel corpo. | response[‘regime’] |
| pay_longitude | È l’angolo misurato tra la direzione dell’equinozio di primavera e il vettore di posizione. | response[‘longitude’] |
| pay_major_axis_km | response[‘major_axis_km’] | |
| pay_eccentricity | Una misura di quanto sia allungata l’orbita del satellite (payload). Un cerchio ha un’eccentricità di 0. Un’ellisse ha eccentricità compresa tra 0 e 1. Una parabola ha un’eccentricità di 1. Un’iperbole ha un’eccentricità maggiore di 1. | response[‘eccentricity’] |
| pay_periapsis_km | Il periapsis d’altra parte è il punto più basso di un’orbita, il punto in cui l’oggetto è più vicino al centro della sua orbita. | response[‘periapsis_km’] |
| pay_apoapsis_km | L’apoapsis si riferisce al punto più alto di un’orbita, dove l’oggetto è il più lontano dal punto in cui orbita. | response[‘apoapsis_km’] |
| pay_inclination | Angolo tra il piano orbitale e il piano di riferimento. | response[‘inclination’] |
| pay_period_min | response[‘period_min’] | |
| pay_lifespan_years | Durata del carico in orbita espressa in anni. | response[‘lifespan_years’] |
| pay_epoch | Un’epoca è solitamente specificata come data giuliana. | response[‘epoch’] |
| pay_mean_motion | Velocità angolare media necessaria per completare un’orbita. | response[‘mean_motion’] |
| pay_raan | Definisce la fasatura angolare relativa tra il piano orbitale e l’equinozio di primavera. | response[‘raan’] |
| pay_arg_of_pericenter | L’angolo dal nodo ascendente al pericentro, misurato nel piano dell’orbita. | response[‘arg_of_pericenter’] |
| pay_mean_anomaly | La posizione del payload nell’orbita: il prodotto il tempo del movimento medio (pay mean motion) e del tempo dal passaggio del pericentro (Time of pericenter passage). | response[‘mean_anomaly’] |
| pay_id | Id univoco del payload | response[‘id’] |
(Caratteristiche del carico estratte con la richiesta API Specifica)
Anche per quel che concerne le informazioni del carico, abbiamo tutte le informazioni che ci servono. Ora non resta che estrarre quelle relative al “launchpad”.
| Nome identificativo elemento ‘Launchpad’ | Descrizione | Codice |
|---|---|---|
| lau_name | Nome codificato della zone di lancio | response[‘name’] |
| lau_full_name | Nome completo della zone di lancio | response[‘full_name’] |
| lau_locality | Nome della località del lancio | response[‘locality’] |
| lau_region | Regione della zona di lancio | response[‘region’] |
| lau_timezone | TimeZone della zona di lancio | response[‘timezone’] |
| lau_latitude | Latitudine della zona di lancio | response[‘latitude’] |
| lau_longitude | Longitudine della zona di lancio | response[‘longitudine’] |
| lau_launch_attemps | Tentativi di lancio | response[‘launch_attemps’] |
| lau_launch_successes | Lanci avvenuti con successo | response[‘launch_successes’] |
| lau_rockets | Id dei razzi lanciati | response[‘rockets’] |
| lau_launches | Id del lanci | response[‘launches’] |
| lau_status | Stato della zona di lancio | response[‘status’] |
| lau_id | Id della zona di lancio | response[‘id’] |
(Caratteristiche della zona di lancio estratte con la richiesta API Specifica)
Adesso, abbiamo tutte le informazioni che ci servono anche del “launchpad”. Nel seguito propongo una versione definitiva del codice che ho sviluppato.
import pandas as pd
import numpy as np
import requests
import datetime
import time
import math
import matplotlib.pyplot as plt
from Database.DataBaseLaunches import Database
def CheckValue(value):
if value is None:
return ''
#funzione che mi permette di estrarre le informazioni specifiche delle missioni
def getElement(data,apielement,element):
i= 0
for x in data[element]:
if not ((x is None) or (x == '')):
if i == 93 and element == 'payloads':
print('i risulta uguale a 93')
if (element == 'payloads' or element == 'launchpads'):
time.sleep(0.5) #add pause
response = requests.get('https://api.spacexdata.com/v4/'+apielement+'/'+str(x[0])).json()
else:
response = requests.get('https://api.spacexdata.com/v4/'+apielement+'/'+str(x)).json()
if element == 'rocket' :
#time.sleep(0.5) #add pause
data.loc[i,'ro_name'] = response['name']
data.loc[i,'ro_stages'] = response['stages']
data.loc[i,'ro_boosters'] = response['boosters']
data.loc[i,'ro_cost_per_launch'] = response['cost_per_launch']
data.loc[i,'ro_first_flight'] = response['first_flight']
data.loc[i,'ro_landing_legs_number'] = response['landing_legs']['number']
data.loc[i,'ro_landing_legs_material'] = response['landing_legs']['material']
data.loc[i,'ro_landing_engine_type'] = response['engines']['type']
data.loc[i,'ro_landing_engine_number'] = response['engines']['number']
data.loc[i,'ro_landing_engine_version'] = response['engines']['version']
data.loc[i,'ro_landing_engine_propellant_1'] = response['engines']['propellant_1']
data.loc[i,'ro_landing_engine_propellant_2'] = response['engines']['propellant_2']
data.loc[i,'ro_engine_layout'] = response['engines']['layout']
if element == 'payloads':
#time.sleep(0.5) #add pause
data.loc[i,'pay_dragon_capsule'] = response['dragon']['capsule']
data.loc[i,'pay_dragon_mass_returned_kg'] = response['dragon']['mass_returned_kg']
data.loc[i,'pay_dragon_mass_returned_lbs'] = response['dragon']['mass_returned_lbs']
data.loc[i,'pay_dragon_flight_time_sec'] = response['dragon']['flight_time_sec']
data.loc[i,'pay_dragon_manifest'] = response['dragon']['manifest']
data.loc[i,'pay_dragon_water_landing'] = response['dragon']['water_landing']
data.loc[i,'pay_dragon_land_landing'] = response['dragon']['land_landing']
data.loc[i,'pay_name'] = response['name']
data.loc[i,'pay_type'] = response['type']
data.loc[i,'pay_reused'] = response['reused']
data.loc[i,'pay_launch'] = response['launch']
data.loc[i,'pay_customers'] = str(response['customers'])
data.loc[i,'pay_norad_ids'] = str(response['norad_ids'])
data.loc[i,'pay_nationalities'] = str(response['nationalities'])
data.loc[i,'pay_manufacturers'] = str(response['manufacturers'])
data.loc[i,'pay_mass_kg'] = response['mass_kg']
data.loc[i,'pay_mass_lbs'] = response['mass_lbs']
data.loc[i,'pay_orbit'] = response['orbit']
data.loc[i,'pay_reference_system'] = response['reference_system']
data.loc[i,'pay_regime'] = response['regime']
data.loc[i,'pay_longitude'] = response['longitude']
data.loc[i,'pay_major_axis_km'] = response['semi_major_axis_km']
data.loc[i,'pay_eccentricity'] = response['eccentricity']
data.loc[i,'pay_periapsis_km'] = response['periapsis_km'] #manca nella tabella
data.loc[i,'pay_apoapsis_km'] = response['apoapsis_km']
data.loc[i,'pay_inclination_deg'] = response['inclination_deg']
data.loc[i,'pay_period_min'] = response['period_min']
data.loc[i,'pay_lifespan_years'] = response['lifespan_years']
data.loc[i,'pay_epoch'] = response['epoch']
data.loc[i,'pay_mean_motion'] = response['mean_motion']
data.loc[i,'pay_raan'] = response['raan']
data.loc[i,'pay_arg_of_pericenter'] = response['arg_of_pericenter']
data.loc[i,'pay_mean_anomaly'] = response['mean_anomaly']
data.loc[i,'pay_id'] = response['id']
if element == 'launchpad':
data.loc[i,'lau_name'] = response['name']
data.loc[i,'lau_full_name'] = response['full_name']
data.loc[i,'lau_locality'] = response['locality']
data.loc[i,'lau_region'] = response['region']
data.loc[i,'lau_timezone'] = response['timezone']
data.loc[i,'lau_latitude'] = response['latitude']
data.loc[i,'lau_longitude'] = response['longitude']
data.loc[i,'lau_launch_attempts'] = response['launch_attempts']
data.loc[i,'lau_launch_successes'] = response['launch_successes']
data.loc[i,'lau_rockets'] = str(response['rockets'])
data.loc[i,'lau_launches'] = str(response['launches'])
data.loc[i,'lau_status'] = response['status'] #manca nella tabella
data.loc[i,'lau_id'] = response['id']
i=i+1
return data
spacex_launches='https://api.spacexdata.com/v5/launches/past'
launches = requests.get(spacex_launches)
# Conversione da json a dataframe
data_launches=pd.json_normalize(launches.json())
data_launches_subdataset = data_launches[['rocket', 'payloads', 'launchpad', 'cores', 'capsules','flight_number', 'date_utc','success','failures','details','name','id']]
# Visualizza le prime 5 righe del dataset
print(data_launches_subdataset.head())
data_launches_subdataset['date'] = pd.to_datetime(data_launches_subdataset['date_utc']).dt.date
data_launches_with_rocket = getElement(data_launches_subdataset,'rockets','rocket')
data_launches_with_launchpads = getElement(data_launches_with_rocket,'launchpads','launchpad')
data_launches_with_payloads = getElement(data_launches_with_rocket,'payloads','payloads')
data_launches_with_rocket = data_launches_with_rocket.fillna('')
db = Database("launches.sqlite3") #connect to database SQL3Lite
db.SalvaDataFrame(data_launches_with_rocket) A questo punto, la tabella Launches del database launches SQLite3 contiene tutte le informazioni per poter iniziare a pensare ad una qualche elaborazione successiva e quindi ad una fase di preparazione per gli algoritmi di Machine Learning.
