notebook.community

Edit and run



In [1]:

    
import numpy as np
from scipy.integrate import trapz 
from matplotlib import pyplot as plt 
import sys 
sys.path.append("./Utils")
sys.path.append("./EntryGuidance")
sys.path.append("./EntryGuidance/SDC")


from EntryEquations import Entry
from InitialState import InitialState
from RK4 import RK4
from TSDRE import TSDRE 

import adaptive
adaptive.notebook_extension()



In [36]:

    
def ring(xy, wait=False):
    import numpy as np
    from time import sleep
    from random import random
    if wait:
        sleep(random()/10)
    x, y = xy
    a = 0.2
    return x + np.exp(-(x**2 + y**2 - 0.75**2)**2/a**4)

def plot(learner):
    plot = learner.plot(tri_alpha=0.2)
    return (plot.Image + plot.EdgePaths.I + plot).cols(2)



In [37]:

    
learner = adaptive.Learner2D(ring, bounds=[(-1, 1), (-1, 1)])



In [38]:

    
runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)



In [39]:

    
runner.live_info()
runner.live_plot(plotter=plot, update_interval=0.1)



In [19]:

    
from SDC.Entry import Range 
def test_range(Inputs):
    a,b = Inputs
    final_range, final_altitude = 720e3 + a*100e3, 6e3 + 2e3*b
    x0 = InitialState()
    model = Entry(Scale=False)
    x0 = model.scale(x0)

    idx = [0, 3, 4]  # grabs the longitudinal states in the correct order 
    x0_sdc = x0[idx]
    x0_sdc[0] = model.altitude(x0_sdc[0]*model.dist_scale)/model.dist_scale


    sdc_model = Range(model, x0[-1])   
    controller = TSDRE()
    def altitude_constraint(h):
        def constraint(x):
            return x[0]-h, np.array([1, 0, 0])
        return constraint 

    problem = {'tf': final_range, 'Q': lambda y: np.diag([0, 0, 0.001])*0, 'R': lambda x: [[1]], 'constraint': altitude_constraint(final_altitude)}

    X = [x0_sdc]
    U = []
    problem['Q'](X[0])
    N = 100
    S = np.linspace(0, problem['tf'], N)

    for i in range(N-1):
#         u = controller(S[i], X[-1], sdc_model, problem)
        u = [0.85]
        if 1:
            u = np.clip(u, 0, 1)  # Optional saturation effects
        xi = RK4(sdc_model.dynamics(u), X[-1], np.linspace(S[i], S[i+1], 3))  # _ steps per control update 
        X.append(xi[-1])
        U.append(u)

    hf = X[-1][0].squeeze()
#     err = (hf - final_altitude)**2/1e6 # km^2 altitude error
    err = np.abs(hf-final_altitude)
    tol = 100 # meters 
    return max(err, tol)/1000 # km



In [20]:

    
learner = adaptive.Learner2D(test_range, bounds=[(0, 1), (0, 1)]) # (720e3, 810e3), (6e3, 10e3)



In [21]:

    
runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)



In [23]:

    
runner.live_info()
runner.live_plot(plotter=plot, update_interval=2)



In [ ]: