Merge pull request #1 from leocelente/map

Added latitude and longitude simulation with GFS forecast data

Author: leocelente

.gitignore

@@ -0,0 +1,6 @@
+# Path is integrated to meters in a flat plane.
+# which is equivalent to a ENU or Local Tangent Plane
+# it is defined through geodesic latitude and longitude
+# so to view it correctly on a map, its also necessary
+# to convert it to geocentric latitude. 
+# METERS (ENU) -> LAT/LNG (GEODETIC) -> LAT/LNG (ECEF)

Air.py

@@ -1,26 +1,28 @@
 from typing import Callable
 import numpy as np
+from numpy import ndarray
 
 '''
 This is from a previous project, I'm trying to reuse code
 '''
 
-def RK4(model: Callable[[float, list[float]], list[float]], state_prev: list[float], t_now: float, t_step: float):
+
+def RK4(model: Callable[[float, ndarray], ndarray], state_prev: ndarray, t_now: float, t_step: float):
     '''
     Range-Kutta 4\nIntegra o estado `state_prev` pelo modelo `model`
     no passo `t_now` até o passo `t_now + t_step`
     '''
-    len = 2
+    len = 2 + 1 + 2
     state_prev = np.ravel(state_prev)
     state_prev = np.reshape(state_prev, (len, 1))
 
-    k1: list[float] = model(t_now, state_prev)
-    k2: list[float] = model(t_now+t_step/2., state_prev + (k1 * t_step/2.))
-    k3: list[float] = model(t_now+t_step/2., state_prev + (k2 * t_step/2.))
-    k4: list[float] = model(t_now+t_step, state_prev + k3 * t_step)
-    k: list[float] = (1/6)*(k1 + 2*k2 + 2*k3 + k4)
+    k1: ndarray = model(t_now, state_prev)
+    k2: ndarray = model(t_now+t_step/2., state_prev + (k1 * t_step/2.))
+    k3: ndarray = model(t_now+t_step/2., state_prev + (k2 * t_step/2.))
+    k4: ndarray = model(t_now+t_step, state_prev + k3 * t_step)
+    k: ndarray = (1/6)*(k1 + 2*k2 + 2*k3 + k4)
 
-    delta_state: list[float] = (k * t_step)
-    state_next:  list[float] = state_prev + delta_state
+    delta_state: ndarray = (k * t_step)
+    state_next:  ndarray = state_prev + delta_state
 
     return state_next

Balloon.py

@@ -5,19 +5,20 @@ Python Simulation of a High Altitude Balloon ascent and descent.
 Create a tool to help experiments involving HABs. Currently focusing efforts on
 the design of an Altitude Control System.
 
-## State
-**Working!**
-Seems to work, but a timestep >= 1s fails to converge.
-
+## Screenshots
+![map](assets/map.png)
 ![screenshot](assets/screenshot.png)
 ![terminal](assets/terminal.png)
 
-## Dependencies
-Just: 
+## Dependencies 
  - `numpy`
  - `matplotlib`
+ - `plotly`
+ - `pandas`
+ - `grequests`
+ - `scipy`
 
-Even so, please, use a virtual environment
+Please, use a virtual environment. 
 
 ## How to use
 ```shell
@@ -37,6 +38,7 @@ $ source .venv/bin/activate
  - `Utils.py`: some conversion functions that don't have a good place yet
  - `Local.py`: Placeholder for variables that could be of use in a future state of the project
  - `Universe.py`: Mostly replaces `Utils.py` keeping purely mathematical formulas 
+ - `thirdparty/`: Contains code from the [Astra Simulator](https://github.com/sobester/astra_simulator/) that handles Global Forecasting System communication and latitude/longitude conversions
 
 The `main.py` code then creates an object of the class Balloon, and passes its collection o models
 to the Simulator,  that then does the integration step.

Geolocation.py

@@ -2,28 +2,31 @@
 import numpy as np
 from Integrator import RK4
 from Local import *
+from numpy import ndarray
 
 '''
 This is from a previous project, I'm trying to reuse code
 '''
 
-def s(progress:float):
-  ''' 
-  Change this parameter to print the progress
-  '''
-  pass
 
+def s(progress: float):
+    ''' 
+    Change this parameter to print the progress
+    '''
+    pass
 
-def Simulate(state: list[float], model, time_start:float=0, time_end: float=30,  time_step:float=1, status=s):
-  '''
-  Run simulation of `model` from `time_start` to `time_end`
-  '''
-  print(f"Simulating from {time_start}s to {time_end}s with dt of {time_step}s")
-  time = np.arange(time_start, time_end, time_step, dtype=float)
 
-  view_state = []
-  for i in range(len(time)):
-      status(i/len(time))
-      state = RK4(model, state, time[i], time_step)
-      view_state.append(state[:, 0])
-  return view_state, time
+def Simulate(state: ndarray, model, time_start: float = 0, time_end: float = 30,  time_step: float = 1, status=s):
+    '''
+    Run simulation of `model` from `time_start` to `time_end`
+    '''
+    print(
+        f"Simulating from {time_start}s to {time_end}s with dt of {time_step}s")
+    time = np.arange(time_start, time_end, time_step, dtype=float)
+
+    view_state = []
+    for i in range(len(time)):
+        status(i/len(time))
+        state = RK4(model, state, time[i], time_step)
+        view_state.append(state[:, 0])
+    return view_state, time